Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/raforg/daemon

turns other processes into daemons
https://github.com/raforg/daemon

bsd c cli daemon daemonize debian freebsd linux macos macosx netbsd openbsd posix redhat svr4 ubuntu unix

Last synced: 3 days ago
JSON representation

turns other processes into daemons

Awesome Lists containing this project

README 

        
README

======

*daemon* - turns other processes into daemons



DESCRIPTION

===========

*Daemon* turns other processes into daemons. There are many tasks that need to

be performed to correctly set up a daemon process. This can be tedious.

*Daemon* performs these tasks for other processes. This is useful for writing

daemons in languages other than *C*, *C++* or *Perl* (e.g. `/bin/sh`, *Java*).



If you want to write daemons in languages that can link against *C* functions

(e.g. *C*, *C++*), see *libslack* which contains the core functionality of *daemon*.



DETAILS

=======

*Daemon* turns other processes into daemons. There are many tasks that need to

be performed to correctly set up a daemon process. This can be tedious.

*Daemon* performs these tasks for other processes.



The preparatory tasks that *daemon* performs for other processes are:



First revoke any setuid or setgid privileges that *daemon* may have been

installed with (by system administrators who laugh in the face of danger).



Process command line options.



Change the root directory if the `--chroot` option was supplied.



Change the process `uid` and `gid` if the `--user` option was supplied. Only

*root* can use this option. Note that the `uid` of *daemon* itself is changed,

rather than just changing the `uid` of the client process.



Read the system configuration file(s) (`/etc/daemon.conf` and

`/etc/daemon.conf.d/*` by default, or specified by the `--config` option)

unless the `--noconfig` option was supplied. Then read the user's personal

configuration file(s) (`~/.daemonrc` and `~/.daemonrc.d/*`), if any. Note:

The root directory and the user must be set before access to the

configuration file(s) can be attempted so neither `--chroot` nor `--user`

options may appear in the configuration file.



On *BSD* systems (except *macOS*), the system configuration file(s) are

`/usr/local/etc/daemon.conf` and `/usr/local/etc/daemon.conf.d/*` by

default.



On *macOS*, when installed via *macports*, the system configuration file(s)

are `/opt/local/etc/daemon.conf` and `/opt/local/etc/daemon.conf.d/*`.



Disable core file generation to prevent leaking potentially sensitive

information in daemons that are run by *root* (unless the `--core` option

was supplied).



Become a daemon process:



  * If *daemon* was not invoked by *init(8)* (i.e. pid 1) or *inetd(8)*:



    * Ignore `SIGHUP` signals in case the current process session leader

      terminates while attached to a controlling terminal, causing us to

      receive a `SIGHUP` signal before we start our own process session below.

      This can happen when *daemon* was invoked interactively via the shell

      builtin `exec`. When this initial process terminates below, the terminal

      emulator that invoked the shell also terminates, so *daemon* needs to

	  protect itself from that.



    * Background the process to lose process group leadership.



    * Start a new process session.



	* Background the process again to lose process session leadership. Under

	  *SVR4* this prevents the process from ever gaining a controlling

	  terminal. This is only necessary under *SVR4*, but is always done for

	  simplicity. Note that ignoring `SIGHUP` signals earlier means that

	  when the newly created process session leader terminates, then even if

	  it has a controlling terminal open, the newly backgrounded process

	  won't receive the corresponding `SIGHUP` signal that is sent to all

	  processes in the process session's foreground process group, because

	  it inherited signal dispositions from the initial process.



  * Change the current directory to the root directory so as not to hamper

    umounts.



  * Clear the *umask* to enable explicit file creation modes.



  * Close all open file descriptors. If *daemon* was invoked by *inetd(8)*,

	`stdin`, `stdout` and `stderr` are left open, because they are open to a

	socket.



  * Open `stdin`, `stdout` and `stderr` to `/dev/null`, in case something

    requires them to be open. Of course, this is not done if *daemon* was

    invoked by *inetd(8)*.



  * If the `--name` option was supplied, create and lock a file containing the

	process id of the *daemon* process. The presence of this locked file

	prevents two instances of a daemon with the same name from running at

	the same time. The default location of the pidfile is `/var/run` for

	*root* (`/etc` on *Solaris*, `/opt/local/var/run` on *macOS* when

	installed via *macports*), and `/tmp` for normal users. If the

	`--pidfiles` option was supplied, its argument specifies the directory

	in which the pidfile will be placed. If the `--pidfile` option was

	supplied, its argument specifies the name of the pidfile and the

	directory in which it will be placed.



If the `--umask` option was supplied, set the *umask* to its argument, which

must be a valid three-digit octal mode. Otherwise, set the *umask* to `022`,

to prevent accidentally creating group- or world-writable files.



Set the current directory if the `--chdir` option was supplied.



Spawn the client command and wait for it to terminate. The client command

can be specified as command line arguments, or as the argument of the

`--command` option. If both the `--command` option and command line

arguments are present, the client command is the result of appending the

command line arguments to the argument of the `--command` option.



If the `--output`, `--stdout` and/or `--stderr` option were supplied, the client's

standard output and/or standard error are captured by *daemon*, and sent to the

respective *syslog* destinations.



When the client terminates, *daemon* respawns it if the `--respawn` option

was supplied. If the client ran for less than `300` seconds (or the value of

the `--acceptable` option), then *daemon* sees this as a failure. It will

attempt to restart the client up to five times (or the value of the

`--attempts` option), before waiting for `300` seconds (or the value of the

`--delay` option). This gives the system administrator the chance to correct

whatever is preventing the client from running successfully without

overloading system resources. If the `--limit` option was supplied, *daemon*

terminates after the specified number of respawn attempt bursts. The default

is zero, which means never give up, never surrender.



When the client terminates, and the `--respawn` option wasn't supplied,

*daemon* terminates as well.



If the `--foreground` option was supplied, the client process is run as a

foreground process, and is not turned into a daemon at all. If *daemon* is

connected to a terminal, then the client process will also be connected to

it. If *daemon* is not connected to a terminal, but the client needs to be

connected to a terminal, use the `--pty` option.



If the `--bind` option was supplied, on systems with *systemd-logind* or

*elogind*, the client process will be terminated when the user logs out.



The `--stop` option sends a `SIGTERM` signal to a currently running named

*daemon*, which causes it to terminate its client process (with a `SIGTERM`

signal), and to then terminate itself.



The `--restart` option sends a `SIGUSR1` signal to a currently running named

*daemon*, which causes it to terminate its client process (with a `SIGTERM`

signal). If the named *daemon* was started with the `--respawn` option, it

will then restart the client. Otherwise, it will terminate itself.



The `--signal` option sends a user-specified signal directly to a currently

running named *daemon*'s client process.



The `--running` option reports whether or not a given named *daemon* process

is currently running.



The `--list` option reports all the currently running named *daemon* processes.



--------------------------------------------------------------------------------



    URL: https://libslack.org/daemon

    URL: https://raf.org/daemon

    GIT: https://github.com/raforg/daemon

    GIT: https://codeberg.org/raforg/daemon

    Date: 20230824

    Author: raf