drlog: Handle the INT signal gracefully

Sending an interrupt signal to a drlog process will make it exit gracefully,
flushing buffers to disk if needed.

dlog: Remove unneded "running" variable

The variable controlling the main loop is never reset, so it can be removed.

dlog: Handle INT, TERM and HUP signals gracefully

* Sending a HUP signal to a dlog process will flush the log file and re-open
  it. This allows e.g. for external rotation of files.
* Sending a TERM or INT signal to a dlog process will close the log file and
  exit gracefully.

Version 0.4.1

Update Debian packaging for version 0.4.1

Define _GNU_SOURCE to get the definition of ULLONG_MAX

System headers with new GCC versions will not include a definition for
ULLONG_MAX, unless C99 mode is turned on, or GNU extensions requested.
As there is no common option for compilers to enable C99 mode, it is
actually easier to define _GNU_SOURCE.

Improve error messages from drlog

Unify all file-like size parsing in util.c

* New common functions storage_size_to_bytes() and storage_size_option()
  --for use with w_opt_t-- in util.{h,c}
* Make drlog use the common functions.

Unify all time-period parsing in util.c

* New common functions time_period_to_seconds() and time_period_option()
  --for use with w_opt_t-- in util.{h,c}
* Make dmon and drlog use the common functions.

Use memory handling functions from libwheel

Removes the usage of the memory handling functions defined in util.{h,c}
and uses the corresponding functions from libwheel where needed.

Remove unneeded die() declaration from util.h

Remove unused include from multicall.c

Change MULTICALL preprocessor define to NO_MULTICALL

Now that building a multicall binary is the default, it looks sensible to
remove the -DMULTICALL from the compiler command line while building, and
adding -DNO_MULTICALL when standalone binaries are requested.

Link dmon to libwheel.a instead all of its object files

This will make the linker discard unused symbols from the static library,
instead of munging together all the libwheel .o object files. Generated
binary size in x86-64 is ~3 kB smaller.

Use $(LD) for libnofork instead of hardcoding gcc command

drlog: Better error formatting

Make error output more consistent with that of dlog and dslog.

drlog: Remove die() macro, use w_die(NULL) instead

drlog: Better output directory errors

Show different messages if the output path does not exists and
if it is a directory, instead of having a single error message
for both cases.

Build a multicall binary by default

In general there is no gain in building separate binaries for each tool, so
it sounds reasonable to assume that by default everybody would like to build
a multicall binary. Still, it is possible to build standalone tools passing
MULTICALL=0 in the Make command line. The README is updated accordingly.

Update libwheel and disable its stdio usage

Use w_io_t instead of libc's stdio

Completely replace assert() with w_assert()

Version 0.4

Update Debian packaging for version 0.4

Same help message in dlog/drlog for -b flag

Make dlog and drlog use the same help message for the -b/--buffered
command line option, avoiding references to fsync(), which is in
fact a technical detail that the user would not care about.

Add -b/--buffered option to drlog

Now drlog works the same as dlog: it flushes data to disk after
each line. Optionally buffered operation can be enabled by passing
-b or --buffered in the command line.

Fix option name in drlog manpage

Option "-t" was used for both both timestamp and max-time,
so changed max-time to "-T", following the actual implementation.

Point to all DMon articles in README file

Instead of linking to a single post in Adrian's blog about
DMon, change the link to point to all the articles on DMon
available.

Do not make non-optimized debug builds by default

Remove usage invalid of optarg

For reporting errors related to opening the status file/fifo,
optarg was being used (a leftover from the pre-wheel era), so
changed it to properly report the path.

Removed section in README about externally adding rotlog

As rotlog is now included in dmon (as drlog), it no longer makes sense
to keep the section in the README file.

Add drlog in Git ignore rules

Import new drlog tool, based on rotlog

Update libwheel submodule to v0.1

Properly detect pid-file command line argument

The option parser was using a global variable, whilst the code
was checking a local one. Removed the local and kept the other.

Use _DEBUG_PRINT for enabling debug output

Remove iolib.{h,c} and use w_io_t functions instead

Improve help output by passing cmdline syntax to w_opt_parse

Update libwheel

Use w_die wherever possible

Disable pthread support from libwheel

Fix file name in comment header

Update code to build with latest libwheel

Use w_lengthof instead of length_of

The libwheel library already includes a macro that calculates array lengths,
so use that instead of dmon's

Update libwheel to latest Git head

Change dslog to use w_opt_parse() from libwheel

Change dlog to use w_opt_parse() from libwheel

Remove unused parse_float_arg() function

Since we are using w_opt_parse() in dmon, this function is no longer needed.

Parse config file with w_opt_parse_file()

Instead of replacing argc/argv (which is hackish), use a proper parser
resuing the long command line options using libwheel's w_opt_parse_file().

Change dmon to use w_opt_parse

Rules in Makefile to build with libwheel

Add Git wheel submodule

Document "-I" option and status file format

This modifies the manual page to have a section on the format used for the
status file updates (picked from the commit message of edf2718), and the
"-I" option to pass the path where to write status updates.

Better debugging message including signal number

Implementing writing process status to file

This makes dmon print lines with status changes to a given file-like
entity (e.g. FIFOs do work). Possible formats for lines are:

- Processes are started or stopped by dmon:

    cmd start <pid>
    log start <pid>
    cmd stop <pid>
    log stop <pid>

- Process has exited by its own means, or was terminated by the other means
different than dmon itself:

    cmd exit <pid> <status>
    log exit <pid> <status>

  The <status> field is numeric, and must be interpreted the same as the
  "status" argument to waitpid(2) system call. Most of the time this is
  the expected integer code passed to exit(2), but this may not be true if
  the process exits forcibly. Likely, this should be changed at some point.

- Signals are being sent to processes:

    cmd signal <pid> <signal>
    log signal <pid> <signal>

- The main process timed out (-t):

    cmd timeout <pid>

- Process was paused or resumed due to system load constraints (-l/-L):

    cmd pause <pid>
    cmd resume <pid>

Sanity-check for printable characters in replace_args_cb()

When reading non-printable characters, assume that binary data is being
read, return an error flag and set "errno" to some sensible value (for
systems which have it defined, EINVAL is used) to signal the error to
the user.

Handle errors when reading file passed to "-C"

In some situations, the file passed with "-C file" may not be readable so
this adds the code to handle such situations.

Document "-C file" commnand line option in manpage

Fix typo (double double-dash) in manual page

In the examples section, one of them contained two double-dash arguments,
which is not a valid combination.

Support reading options from files with "-C file"

This implements very basic support for reading options from files.
Note that this reads "options from files", it does not read "proper
configuration files", so implementation is somewhat dodgy -- but it
the most we can do with the less possible code. It works this way:

- If "-C" is exactly the first argument and there are at least two
arguments, the second one is expected to be a file name.
- Arguments are shifted two positions to the left.
- Contents from the file are placed in the argv array by using
replace_args_file().
- Contents of the file will be happily "parsed" by getopt().

This is similar to what is done with the contents of the DMON_OPTIONS
environment variable.

Release v0.3.7

Ignore shared libraries (*.so) in Git

Fix muilticall builds without rotlog

When builing like this (without "ROTLOG=..."):

  make MULTICALL=1

caused linking to fail because of an undefined symbol. This patch fixes
that kind of builds.

Describe option "-E" in manual page

Add a description in the manual page regarding usage of the "-E" option used
to manipulate the environment variables.

Implement modifying environment variables with "-E"

- Using "-E foo" clears a variable *and* removes it from the environment.
- Using "-E foo=" clears a variable, but it is left in the environment (with
an empty value, of course)
- Using "-E foo=bar" defines a variable and its value.

Add libnofork.so and support its building

When passing LIBNOFORK=1 to Make:

- nofork.c will be compiled to libnofork.so
- libnofork.so will be installed to $(prefix)/lib

This small library is intended to be used with LD_PRELOAD to prevent
processes from forking.

Update manual pages with notes on environment vars

Add notes in manual pages stating that tools honor the corresponding
environment variables for additional options.

Honor DSLOG_OPTIONS environment variable

If DSLOG_OPTIONS is defined in the environment, it will be used to pick up
additional command line arguments.

Honor DLOG_OPTIONS environment variable

If DLOG_OPTIONS is defined in the environment, it will be used to pick up
additional command line arguments.

Honor DMON_OPTIONS environment variable

If DMON_OPTIONS is defined in the environment, it will be used to pick
additional command line arguments.

Memory and arg-replacing utility functions

Provides additions to util.[hc], first the memory functions:

- xxalloc(), which handles allocation, resizing and freeing. Plus utility
macros: xmalloc(), xrealloc(), xfree().
- xalloc() and xresize(), which work for typed dynamic arrays of elements.
A type is passed to the macros.

Then, for replacing (argc, argv) from different sources:

- A generic replace_args_cb() which replaces by reading characters from
a callback function.
- Convenience functions: replace_args_fd(), from an open file descriptor;
replace_args_file(), from a given file by name; replace_args_string(),
which reads characters from the passed string.

All arg-replacing functions leave the original argv[0] at position zero, the
read arguments next, and then the original elements at the end.

Support in Makefile to build multicall binary with rotlog

This is a bit hackish, but allows building "rotlog" inside the "dmon"
multicall binary. To use it, pass the "ROTLOG=path/to/rotlog/source"
variable when building.

Release v0.3.6

Update manual page with "-r" option

Add section on the manual page describing the option for setting process
limits to keep it up to date with the implementation.

Build by default optimized for size (-Os)

Make safe_setrlimit() print limit names on failure

This uses limit_name() to make error messages more meaningful.

Implement setting process limits

This is done by using parse_limit_arg(), saving items to arrays, and doing
limit setup in the child once it was spawned, but before file redirection,
and other tweaks done before execvp().

Implement parse_limit_arg() and limit_name()

Convenience functions to parse "limit=value" arguments, as passed to the
"-r" command line flag. As a bonus, limit_name() can be used to get the name
of a limit given its numeric value.

Add length_of macro to util.h

New safe_setrlimit() function

Hides using "struct rlimit", and aborts program execution when errors occur.
This is a convenience function which will be used to control process limits.

Release v0.3.5

Add "-i" and remove "-?" in manual page

Updates the manual page to state the current behavior of dmon. The "-i"
option was added, along with a clarification about how to specify time
intervals using suffixes. The "-?" option is no longer valid.

Remove "-?" as valid command line flag

The getopt() uses the "?" as character for signalling an invalid command
line option, so dmon must not use it by itself.

Move "-1" in help message to exec constraints section

The option controls process execution, so it belongs to the "process
execution constraints" epigraph in the help text.

Implement sleeping an interval between succesful runs

Add a new "-i" flag, which is passed a time interval. When the process exits
with a zero return code, then the wait is done before the next run. This can
be used to make dmon behave as el-cheapo cron daemon. As it makes no sense
using this option along with "-1", an error is given back to the user when
both options are passed in the command line.

Refactored code for better reusability of functions

- Move parse_float_arg() and parse_time_arg() to util.[hc]
- Move become_daemon() to util.[hc]
- Moved safe_sleep() to util.[hc]
- Factor out task_t handling code to task.[hc]

Explictly ignore return value of write() in iolib

When building with -D_FORTIFY_SOURCE=1 the compiler will complain about the
return value for write() --inside the die() macro-- being ignored. In this
particular case we want it to be actually ignored because it is unknown
whether the call would succeed, and also we do not care because the program
will abort execution afterwards.

Avoid warning about signed vs. unsigned comparisons

Second argument to format_ulong() and format_ullong() was declared as "int",
when in fact those functions are never called with negative values. By
changing the declaration to use "unsigned" instead will make the compiler
not complain.

Handle errors when creating command<->log pipes

When calling pipe() to create the pipe put in between the main process and
the logging process, the return value was not being taken into account. This
makes dmon die() in failure.

New "strip" target in Makefile

Allows for "make strip". Also works properly with "make MULTICALL=1 strip".

Support building all tools as a multicall binary

This enables building all tools into a single executable, being the tools
chosen by inspecting argv[0]. This is good to save space i.e. in embedded
devices and also some memory because of sharability of the text segment.

To make such a build, just pass MULTICALL=1 to Make.

Release v0.3.4

util: Use primary group for the user

Changed name_to_uid() to be name_to_uidgid(), so we get the primary group to
which we do setgid() from the password database entry, this way we ensure
that the group always exists and that it is the primary group of the user.

Apart from removing the potential flaw of a group named exactly like the
specified user, this behavior is more predictable and it is likely that
users would expect dmon to work like this.

Release v0.3.3

Set additional groups prior to execution

Implements setting additional groups passed to -u/-U as a colon-separated
list. This is done using setgroups(2) before dropping privileges.

Update manual pages for -u/-U

Keep manual page up-to-date with the latest change to how parsing is done
for -u/-U.

Do -u/-U in terms of parse_uidgids() removing -g/-G

This used parse_uidgids() to get the user and group list for the -u and -U
options. This makes -g and -G unnecessary because now groups are specified
as a colon-separated list to -u/-U.

util: Add function to parse uid[:gid[:gid...]] lists

This adds a function parse_uidgids() which will parse lists with an UID and
any number of GIDs separated by colons.

Release v0.3.2

Added COPYING and (simple) README

The README for the moment refers to the DMon blog post and the manual pages.
That should suffice for now.