Section 13.6. Daemon Conventions

13.6. Daemon Conventions

Several common conventions are followed by daemons in the UNIX System.

• If the daemon uses a lock file, the file is usually stored in /var/run. Note, however, that the daemon might need superuser permissions to create a file here. The name of the file is usually name.pid, where name is the name of the daemon or the service. For example, the name of the cron daemon's lock file is /var/run/crond.pid.

• If the daemon supports configuration options, they are usually stored in /etc. The configuration file is named name.conf, where name is the name of the daemon or the name of the service. For example, the configuration for the syslogd daemon is /etc/syslog.conf.

• Daemons can be started from the command line, but they are usually started from one of the system initialization scripts (/etc/rc* or /etc/init.d/*). If the daemon should be restarted automatically when it exits, we can arrange for init to restart it if we include a respawn enTRy for it in /etc/inittab.

• If a daemon has a configuration file, the daemon reads it when it starts, but usually won't look at it again. If an administrator changes the configuration, the daemon would need to be stopped and restarted to account for the configuration changes. To avoid this, some daemons will catch SIGHUP and reread their configuration files when they receive the signal. Since they aren't associated with terminals and are either session leaders without controlling terminals or members of orphaned process groups, daemons have no reason to expect to receive SIGHUP. Thus, they can safely reuse it.

Example

The program shown in Figure 13.7 shows one way a daemon can reread its configuration file. The program uses sigwait and multiple threads, as discussed in Section 12.8.

We call daemonize from Figure 13.1 to initialize the daemon. When it returns, we call already_running from Figure 13.6 to ensure that only one copy of the daemon is running. At this point, SIGHUP is still ignored, so we need to reset the disposition to the default behavior; otherwise, the thread calling sigwait may never see the signal.

We block all signals, as is recommended for multithreaded programs, and create a thread to handle signals. The thread's only job is to wait for SIGHUP and SIGTERM. When it receives SIGHUP, the thread calls reread to reread its configuration file. When it receives SIGTERM, the thread logs a message and exits.

Recall from Figure 10.1 that the default action for SIGHUP and SIGTERM is to terminate the process. Because we block these signals, the daemon will not die when one of them is sent to the process. Instead, the thread calling sigwait will return with an indication that the signal has been received.

Figure 13.7. Daemon rereading configuration files

 #include "apue.h" #include <pthread.h> #include <syslog.h> sigset_t    mask; extern int already_running(void); void reread(void) {     /* ... */ } void * thr_fn(void *arg) {     int err, signo;     for (;;) {         err = sigwait(&mask, &signo);         if (err != 0) {             syslog(LOG_ERR, "sigwait failed");             exit(1);         }         switch (signo) {         case SIGHUP:             syslog(LOG_INFO, "Re-reading configuration file");             reread();             break;         case SIGTERM:             syslog(LOG_INFO, "got SIGTERM; exiting");             exit(0);         default:             syslog(LOG_INFO, "unexpected signal %d\n", signo);         }     }     return(0); } int main(int argc, char *argv[]) {     int                 err;     pthread_t           tid;     char                *cmd;     struct sigaction    sa;     if ((cmd = strrchr(argv[0], '/')) == NULL)         cmd = argv[0];     else         cmd++;     /*      * Become a daemon.      */     daemonize(cmd);     /*      * Make sure only one copy of the daemon is running.      */     if (already_running()) {         syslog(LOG_ERR, "daemon already running");         exit(1);     }     /*      * Restore SIGHUP default and block all signals.      */     sa.sa_handler = SIG_DFL;     sigemptyset(&sa.sa_mask);     sa.sa_flags = 0;     if (sigaction(SIGHUP, &sa, NULL) < 0)         err_quit("%s: can't restore SIGHUP default");     sigfillset(&mask);     if ((err = pthread_sigmask(SIG_BLOCK, &mask, NULL)) != 0)         err_exit(err, "SIG_BLOCK error");     /*      * Create a thread to handle SIGHUP and SIGTERM.      */     err = pthread_create(&tid, NULL, thr_fn, 0);     if (err != 0)         err_exit(err, "can't create thread");     /*      * Proceed with the rest of the daemon.      */     /* ... */     exit(0); } 

Example

As noted in Section 12.8, Linux threads behave differently with respect to signals. Because of this, identifying the proper process to signal in Figure 13.7 will be difficult. In addition, we aren't guaranteed that the daemon will react as we expect, because of the implementation differences.

The program in Figure 13.8 shows how a daemon can catch SIGHUP and reread its configuration file without using multiple threads.

After initializing the daemon, we install signal handlers for SIGHUP and SIGTERM. We can either place the reread logic in the signal handler or just set a flag in the handler and have the main thread of the daemon do all the work instead.

Figure 13.8. Alternate implementation of daemon rereading configuration files

 #include "apue.h" #include <syslog.h> #include <errno.h> extern int lockfile(int); extern int already_running(void); void reread(void) {     /* ... */ } void sigterm(int signo) {     syslog(LOG_INFO, "got SIGTERM; exiting");     exit(0); } void sighup(int signo) {     syslog(LOG_INFO, "Re-reading configuration file");     reread(); } int main(int argc, char *argv[]) {     char                *cmd;     struct sigaction    sa;     if ((cmd = strrchr(argv[0], '/')) == NULL)         cmd = argv[0];     else         cmd++;     /*      * Become a daemon.      */     daemonize(cmd);     /*      * Make sure only one copy of the daemon is running.      */     if (already_running()) {         syslog(LOG_ERR, "daemon already running");         exit(1);     }     /*      * Handle signals of interest.      */     sa.sa_handler = sigterm;     sigemptyset(&sa.sa_mask);     sigaddset(&sa.sa_mask, SIGHUP);     sa.sa_flags = 0;     if (sigaction(SIGTERM, &sa, NULL) < 0) {         syslog(LOG_ERR, "can't catch SIGTERM: %s", strerror(errno));         exit(1);     }     sa.sa_handler = sighup;     sigemptyset(&sa.sa_mask);     sigaddset(&sa.sa_mask, SIGTERM);     sa.sa_flags = 0;     if (sigaction(SIGHUP, &sa, NULL) < 0) {         syslog(LOG_ERR, "can't catch SIGHUP: %s", strerror(errno));         exit(1);     }     /*      * Proceed with the rest of the daemon.      */     /* ... */     exit(0); }