Writing UNIX-daemons implies writing a lot of highly repeatable code. On the other hand, this code might be written and debugged once and used in many programs which need to function like daemons. This problem was addressed on BSD UNIX derivatives via a daemon() function although partially - this function implements only a subset of the steps needed to be performed during daemon initialization on most UNIX-like operating systems.

This project implements two functions (roughly modelled on BSDs' daemon()) which might be used in a project to daemonize process on UNIX-like operating systems which follow System V semantics as well as other UNIX derivatives. These functions fully implement all the steps that need to be performed by a classical daemon process (e.g. double-forking, PID-file checking, creation and locking, etc).

Please see the following post for the additional information.

extern pid_t daemonize(int flags)

It is a low-level function to daemonize process. Roughly corresponds to the BSDs' daemon() function but uses the double-fork technique (which is important on System V flavoured Unix systems) and allows specifying more daemonization parameters.

• int flags - a bit mask of the daemon creation flags:
  • DMN_DEFAULT - Create daemon with default daemonization parameters (close existing file descriptors, reset signal handlers, change the current directory to /, set umask to 0).
  • DMN_NO_CLOSE - Do not close existing file descriptors and do not redirect standard file descriptors to /dev/null.
  • DMN_KEEP_SIGNAL_HANDLERS - Do not reset signal handlers to their defaults.
  • DMN_NO_CHDIR - Do not change the current directory of the daemon to /.
  • DMN_NO_UMASK - Do not set umask to 0.

daemonize() follows fork() semantics. By design, the function returns PID of the process to the parent process (which starts daemon) or 0 to the daemon process. On error it returns -1 - this value might be returned to both parent and daemon process. In this case, errno value will be set accordingly.

extern pid_t rundaemon(int flags,
                       int (*daemon_func)(void *udata),
                       void *udata,
                       int *exit_code,
                       const char *pid_file_path);

It is a thin wrapper on top of daemonize() which might check and create PID-file if desired. It is recommended to use this function instead of daemonize() whenever applicable.

• int flags - daemon creation flags, see above;
• int (*daemon_func)(void *udata) - function pointer to the function to be called after successful daemonization (actual daemon body);
• void *udata - pointer to be passed as the value in a call to daemon_func;
• int exit_code - pointer to variable to receive value returned by daemon_func;
• const char *pid_file_path - full pathname to the PID-file. This file will be used for checking if the daemon is not already running (by checking if the file exists and locked) and will be created if not exists. On the daemon exit, this file will be removed under normal conditions. This value might be NULL, in this case no any checks performed and no file will be created.

This functions shares return values with daemonize() function mentioned above with one notable addition - if daemon already running it will return -2 to the process which starts the daemon. No daemonization will be performed in this case.

There are two examples which come with this project. They could be used as the template for one's own daemon:

• example_portable.c - an example of the portable daemon. It uses the self-pipe trick for signal handling.
• example_linux.c - this non-portable example is somewhat shorter and easier to follow because it relies on the Linux specific signalfd(2) for signal handling.