daemonize.c

/***************************************************************************
 * CVSID: $Id: daemonize.c,v 1.18 2004/08/07 15:10:47 stefanb Exp $
 *
 * daemonize.c : Daemonize handler
 *
 * Copyright (C) 2004 Stefan Bambach, <sbambach@gmx.net>
 *
 * Licensed under the GNU General Public License 2.0
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 **************************************************************************/
 
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <syslog.h>

#include "file.h"
#include "errmanager.h"
#include "daemonize.h"
#include "dbug_mem.h"



extern int errno;



int
sb_daemon_drop_privileges(void)
{
    uid_t uid = getuid();
    gid_t gid = getgid();
    uid_t euid = geteuid();
    gid_t egid = getegid();

    // set egid=gid
    if (egid != gid && (setgid(gid) == -1 || getegid() != getgid())) {
        return -1;
    }

    // set euid=uid
    if (euid != uid && (setuid(uid) == -1 || geteuid() != getuid())) {
        return -1;
    }

    // closes the /etc/passwd file
    endpwent();
    // closes the /etc/group file
    endgrent();

    return 0;
}



int
sb_daemon_no_corefile(void)
{
    struct rlimit limit[1] = {{ 0, 0 }};

    if (getrlimit(RLIMIT_CORE, limit) == -1) {
        return -1;
    }

    limit->rlim_cur = 0;

    if (setrlimit(RLIMIT_CORE, limit) != 0) {
        return -1;
    }
    
    return 0;
}



int
sb_daemon_is_started_by_init(void)
{
    // get parents pid (init is the first process)
    if (getppid() == 1) {
        return 1;
    }
    
    return 0;
}



int
sb_daemon_is_started_by_inetd(void)
{
    size_t param_length = sizeof(int);
    int socket_type;

    // check for type of stdin socket (inetd will set it appropriate)
    if (getsockopt(STDIN_FILENO, SOL_SOCKET, SO_TYPE, 
                        &socket_type, (void *)&param_length) == 0) {
        return 1;
    }
    
    return 0;
}



int
sb_daemon_is_started_by_root(void)
{
    if (getuid() != 0) {
        return 0;
    }
    
    return 1;
}



int
sb_daemon_is_started_suid(void)
{
    // started suid, if effective and real IDs doesn't match

    // check for sgid
    if (getgid() != getegid()) {
        return 1;
    }
    
    // check for suid
    if (getuid() != geteuid()) {
        return 1;
    }
    
    return 0;
}



int
sb_daemon_create_fd(int fd, int mode)
{
    int i;
    
    // create fd
    if ((i = open("/dev/null", mode)) == -1) {
        return -1;
    }
    // check, if it is correct file descriptor
    if (i != fd) {
        if (dup2(i, fd) == -1) {
            return -1;
        }
        close(i);
    }

    return fd;
}



int
sb_daemon_change_user(uid_t uid, gid_t gid)
{
    // daemon started by root ?
    if (sb_daemon_is_started_by_root() == 0) {
        return -1;
    }
    
    // set gid, and check if gid and egid are set appropriate
    if ((setgid(gid) == -1) || (getgid() != gid) || (getegid() != gid)) {
        return -1;
    }
    
    // set uid, and check if uid and euid are set appropriate
    if ((setuid(uid) == -1) || (getuid() != uid) || (geteuid() != uid)) {
        return -1;
    }
    
    return 0;
}



int
sb_daemon_detach(const char *rundir)
{
    long i;
    pid_t pid;

    // check for startup as root user (needed for change user, ...)
    if (sb_daemon_is_started_by_root() == 0) {
        return -1;
    }
    
    //
    // see also http://www.unixguide.net/unix/programming/1.7.shtml
    //
    // Almost none of this is necessary (or advisable) if your daemon is being
    // started by inetd. In that case, stdin, stdout and stderr are all
    // set up for you to refer to the network connection, and the
    // fork()s and session manipulation should not be done (to
    // avoid confusing inetd). Only the chdir() and
    // umask() steps remain as useful.
    if ((!sb_daemon_is_started_by_init()) && (!sb_daemon_is_started_by_inetd())) {
        
        // fork() so the parent can exit, this returns control to the
        // command line or shell invoking your program. This step is required
        // so that the new process is guaranteed not to be a process group 
        // leader. The next step, setsid(), fails if you're a process group 
        // leader.
        pid = fork();
        if (pid == -1) {
            return -1;
        }
        if (pid != 0) {
            exit(EXIT_SUCCESS);
        }

        // setsid() to become a process group and session group
        // leader. Since a controlling terminal is associated with a session, 
        // and this new session has not yet acquired a controlling terminal 
        // our process now has no controlling terminal, which is a Good Thing 
        // for daemons.
        setsid();

        // Ignore SIGHUP. When session leader terminates, it will send a SIGHUP
        // signal to all child processes ("to us"). Your daemon should handle 
        // this signal after daemonizing has completed.
        signal(SIGHUP, SIG_IGN);

        // fork() again so the parent, (the session group leader), can exit.
        // This means that we, as a non-session group leader, can never regain
        // a controlling terminal.
        pid = fork();
        if (pid == -1) {
            return -1;
        }
        if (pid != 0) {
            exit(EXIT_SUCCESS);
        }

    }

    // chdir("/") to ensure that our process doesn't keep any directory
    // in use. Failure to do this could make it so that an administrator
    // couldn't unmount a filesystem, because it was our current directory.
    // 
    // [Equivalently, we could change to any directory containing files
    // important to the daemon's operation.]
    if (rundir != NULL) {
        struct stat st;
        if ((stat(rundir, &st) == 0) && (S_ISDIR(st.st_mode))) {
            chdir(rundir);
        } else {
            return -1;
        }
    } else {
        chdir("/");
    }
    
    // umask(0) so that we have complete control over the permissions of
    // anything we write. We don't know what umask we may have inherited.
    umask(0);

    // close() fds 0, 1, and 2. This releases the standard in, out, and
    // error we inherited from our parent process. We have no way of knowing
    // where these fds might have been redirected to. Note that many daemons
    // use sysconf() to determine the limit _SC_OPEN_MAX.
    // _SC_OPEN_MAX tells you the maximun open files/process. Then in a
    // loop, the daemon can close all possible file descriptors. You have to
    // decide if you need to do this or not. If you think that there might be
    // file-descriptors open you should close them, since there's a limit on
    // number of concurrent file descriptors.
    if (sb_daemon_is_started_by_inetd() == 1) {
        // started by inetd: close all fds, but stdin, stdout and stderr
        for (i = 0; i < sysconf(_SC_OPEN_MAX); i++) {
            if ((i!=STDIN_FILENO) && (i!=STDOUT_FILENO) && (i!=STDERR_FILENO)) {
                close(i);
            }
        }
    } else {
        // started normal: close all fds
        for (i = 0; i < sysconf(_SC_OPEN_MAX); i++) {
            close(i);
        }
    }

    // Establish new open descriptors for stdin, stdout and stderr. Even if you
    // don't plan to use them, it is still a good idea to have them open. The
    // precise handling of these is a matter of taste; if you have a logfile,
    // for example, you might wish to open it as stdout or stderr, and open
    // `/dev/null' as stdin; alternatively, you could open
    // `/dev/console' as stderr and/or stdout, and `/dev/null' as
    // stdin, or any other combination that makes sense for your particular
    // daemon. 
    if (sb_daemon_is_started_by_inetd() == 0) {
        // NOT started by inetd, so open stdin, stdout and stderr again
        
        // stdin
        if (sb_daemon_create_fd(STDIN_FILENO, O_RDONLY) == -1) {
            return -1;
        }
        
        // stdout
        if (sb_daemon_create_fd(STDOUT_FILENO, O_WRONLY) == -1) {
            return -1;
        }
        
        // stderr
        if (sb_daemon_create_fd(STDERR_FILENO, O_WRONLY) == -1) {
            return -1;
        }
    }
    
    return 0;
}



int
sb_daemon_init(const char *name,
                    const char *rundir,
                    const char *pidfile)
{
    int fd = -1;

    if (sb_daemon_is_running(pidfile) == 1) {
        return -1;
    }
    
    // close logging before detaching (syslog wrapper)
    emClose();

    // daemonize process
    if (sb_daemon_detach(rundir) != 0) {
        // initialize error manager again
        emInit(LOG_DEBUG, EM_TYPE_SYSLOG, NULL, NULL, NULL, name);
        return -1;
    }
    
    // initialize error manager again
    emInit(LOG_DEBUG, EM_TYPE_SYSLOG, NULL, NULL, NULL, name);

    // generate pidfile
    if (pidfile != NULL) {
        if ((fd = sb_daemon_pidfile_create_and_lock(pidfile)) == -1) {
            return -1;
        }
        if (sb_daemon_pidfile_write(fd) == -1) {
            return -1;
        }
    }
    
    return 0;
}



int 
sb_daemon_is_running(const char *pidfile)
{
    int fd = -1;
    
    // check for parameter and set errno appropriately
    if (pidfile == NULL) {
        return ERRNO(EINVAL);
    }
    
    // try to get pidfile
    if ((fd = sb_daemon_pidfile_create_and_lock(pidfile)) == -1) {
        if ((errno == EACCES) || (errno == EAGAIN)) {
            // locked -> another daemon is running
            return 1;
        }
        // error
        return -1;
    }
    
    // not locked -> remove old pidfile
    sb_file_close(fd);
    sb_file_remove(pidfile);
    
    return 0;
}



int 
sb_daemon_destroy(const char *pidfile)
{
    // remove pidfile
    sb_file_remove(pidfile);
    
    return 0;
}



int
sb_daemon_pidfile_create_and_lock(const char *pidfile)
{
    int fd = -1;
    
    // O_EXCL is broken on NFS file systems, programs which rely
    // on it for performing locking tasks will contain a race condition.
    // see also 'man 2 open'
    
    // try to open pidfile (will fail, if already existing)
    if ((fd = sb_file_open_ext(pidfile, 
                            O_RDWR | O_SYNC | O_CREAT | O_EXCL, 
                            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
    {
        // return error, if not EEXIST
        if (errno != EEXIST) {
            return -1;
        }
        
        // try to open file. This will fail, if another daemon is running
        // and holds the lock.
        if ((fd = sb_file_open(pidfile, O_RDWR | O_SYNC)) == -1) {
            return -1;
        }
    }
    
    // try to get the lock for pidfile
    if (sb_file_lock_acquire_write(fd) == -1) {
        return -1;
    }
    
    return fd;
}



int
sb_daemon_pidfile_write(int fd)
{
    ssize_t written = 0;
    char data[MAX_PIDDATA_LENGTH];
    
    // write pid to pidfile
    memset(data, 0, sizeof(data));
    snprintf(data, MAX_PIDDATA_LENGTH, "%d\n", (int)getpid());
    data[MAX_PIDDATA_LENGTH-1] = '\0';
    
    // seek to begin
    lseek(fd, 0, SEEK_SET);
    
    // write data
    if ((written = write(fd, data, strlen(data))) == -1) {
        return -1;
    }
    if ((size_t)written < strlen(data)) {
        return -1;
    }
    
    // sync out data
    fsync(fd);
    sync();
    
    return 0;
}



pid_t
sb_daemon_pidfile_read(const char *pidfile)
{
    int fd = -1;
    char data[MAX_PIDDATA_LENGTH];
    int pid = -1;
    
    if ((fd = sb_file_open(pidfile, O_RDONLY)) == -1) {
        return -1;
    }
    
    memset(data, 0, sizeof(data));
    if (read(fd, &data, MAX_PIDDATA_LENGTH) == -1) {
        return -1;
    }
    
    if (sscanf(data, "%d", &pid) != 1) {
        return -1;
    }
    
    return pid;
}

---