/***
  This file is part of libdaemon.

  Copyright 2003-2008 Lennart Poettering

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.

***/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <assert.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <dirent.h>

#include "dfork.h"
#include "dnonblock.h"
#include "dlog.h"

#if defined(_NSIG) /* On glibc NSIG does not count RT signals */
# define SIGNAL_UPPER_BOUND _NSIG
#elif defined(NSIG) /* Solaris defines just this */
# define SIGNAL_UPPER_BOUND NSIG
#else
# error "Unknown upper bound for signals"
#endif

static int _daemon_retval_pipe[2] = { -1, -1 };

static int _null_open(int f, int fd) {
    int fd2;

    if ((fd2 = open("/dev/null", f)) < 0)
        return -1;

    if (fd2 == fd)
        return fd;

    if (dup2(fd2, fd) < 0)
        return -1;

    close(fd2);
    return fd;
}

static ssize_t atomic_read(int fd, void *d, size_t l) {
    ssize_t t = 0;

    while (l > 0) {
        ssize_t r;

        if ((r = read(fd, d, l)) <= 0) {

            if (r < 0)
                return t > 0 ? t : -1;
            else
                return t;
        }

        t += r;
        d = (char*) d + r;
        l -= r;
    }

    return t;
}

static ssize_t atomic_write(int fd, const void *d, size_t l) {
    ssize_t t = 0;

    while (l > 0) {
        ssize_t r;

        if ((r = write(fd, d, l)) <= 0) {

            if (r < 0)
                return t > 0 ? t : -1;
            else
                return t;
        }

        t += r;
        d = (const char*) d + r;
        l -= r;
    }

    return t;
}

static int move_fd_up(int *fd) {
    assert(fd);

    while (*fd <= 2) {
        if ((*fd = dup(*fd)) < 0) {
            daemon_log(LOG_ERR, "dup(): %s", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static void sigchld(int s) {
}

pid_t daemon_fork(void) {
    pid_t pid;
    int pipe_fds[2] = {-1, -1};
    struct sigaction sa_old, sa_new;
    sigset_t ss_old, ss_new;
    int saved_errno;

    memset(&sa_new, 0, sizeof(sa_new));
    sa_new.sa_handler = sigchld;
    sa_new.sa_flags = SA_RESTART;

    if (sigemptyset(&ss_new) < 0) {
        daemon_log(LOG_ERR, "sigemptyset() failed: %s", strerror(errno));
        return (pid_t) -1;
    }

    if (sigaddset(&ss_new, SIGCHLD) < 0) {
        daemon_log(LOG_ERR, "sigaddset() failed: %s", strerror(errno));
        return (pid_t) -1;
    }

    if (sigaction(SIGCHLD, &sa_new, &sa_old) < 0) {
        daemon_log(LOG_ERR, "sigaction() failed: %s", strerror(errno));
        return (pid_t) -1;
    }

    if (sigprocmask(SIG_UNBLOCK, &ss_new, &ss_old) < 0) {
        daemon_log(LOG_ERR, "sigprocmask() failed: %s", strerror(errno));

        saved_errno = errno;
        sigaction(SIGCHLD, &sa_old, NULL);
        errno = saved_errno;

        return (pid_t) -1;
    }

    if (pipe(pipe_fds) < 0) {
        daemon_log(LOG_ERR, "pipe() failed: %s", strerror(errno));

        saved_errno = errno;
        sigaction(SIGCHLD, &sa_old, NULL);
        sigprocmask(SIG_SETMASK, &ss_old, NULL);
        errno = saved_errno;

        return (pid_t) -1;
    }

    if ((pid = fork()) < 0) { /* First fork */
        daemon_log(LOG_ERR, "First fork() failed: %s", strerror(errno));

        saved_errno = errno;
        close(pipe_fds[0]);
        close(pipe_fds[1]);
        sigaction(SIGCHLD, &sa_old, NULL);
        sigprocmask(SIG_SETMASK, &ss_old, NULL);
        errno = saved_errno;

        return (pid_t) -1;

    } else if (pid == 0) {
        pid_t dpid;

        /* First child. Now we are sure not to be a session leader or
         * process group leader anymore, i.e. we know that setsid()
         * will succeed. */

        if (daemon_log_use & DAEMON_LOG_AUTO)
            daemon_log_use = DAEMON_LOG_SYSLOG;

        if (close(pipe_fds[0]) < 0) {
            daemon_log(LOG_ERR, "close() failed: %s", strerror(errno));
            goto fail;
        }

        /* Move file descriptors up*/
        if (move_fd_up(&pipe_fds[1]) < 0)
            goto fail;

        if (_daemon_retval_pipe[0] >= 0 && move_fd_up(&_daemon_retval_pipe[0]) < 0)
            goto fail;
        if (_daemon_retval_pipe[1] >= 0 && move_fd_up(&_daemon_retval_pipe[1]) < 0)
            goto fail;

        if (_null_open(O_RDONLY, 0) < 0) {
            daemon_log(LOG_ERR, "Failed to open /dev/null for STDIN: %s", strerror(errno));
            goto fail;
        }

        if (_null_open(O_WRONLY, 1) < 0) {
            daemon_log(LOG_ERR, "Failed to open /dev/null for STDOUT: %s", strerror(errno));
            goto fail;
        }

        if (_null_open(O_WRONLY, 2) < 0) {
            daemon_log(LOG_ERR, "Failed to open /dev/null for STDERR: %s", strerror(errno));
            goto fail;
        }

        /* Create a new session. This will create a new session and a
         * new process group for us and we will be the ledaer of
         * both. This should always succeed because we cannot be the
         * process group leader because we just forked. */
        if (setsid() < 0) {
            daemon_log(LOG_ERR, "setsid() failed: %s", strerror(errno));
            goto fail;
        }

        umask(0077);

        if (chdir("/") < 0) {
            daemon_log(LOG_ERR, "chdir() failed: %s", strerror(errno));
            goto fail;
        }

        if ((pid = fork()) < 0) { /* Second fork */
            daemon_log(LOG_ERR, "Second fork() failed: %s", strerror(errno));
            goto fail;

        } else if (pid == 0) {
            /* Second child. Our father will exit right-away. That way
             * we can be sure that we are a child of init now, even if
             * the process which spawned us stays around for a longer
             * time. Also, since we are no session leader anymore we
             * can be sure that we will never acquire a controlling
             * TTY. */

            if (sigaction(SIGCHLD, &sa_old, NULL) < 0) {
                daemon_log(LOG_ERR, "close() failed: %s", strerror(errno));
                goto fail;
            }

            if (sigprocmask(SIG_SETMASK, &ss_old, NULL) < 0) {
                daemon_log(LOG_ERR, "sigprocmask() failed: %s", strerror(errno));
                goto fail;
            }

            if (signal(SIGTTOU, SIG_IGN) == SIG_ERR) {
                daemon_log(LOG_ERR, "signal(SIGTTOU, SIG_IGN) failed: %s", strerror(errno));
                goto fail;
            }

            if (signal(SIGTTIN, SIG_IGN) == SIG_ERR) {
                daemon_log(LOG_ERR, "signal(SIGTTIN, SIG_IGN) failed: %s", strerror(errno));
                goto fail;
            }

            if (signal(SIGTSTP, SIG_IGN) == SIG_ERR) {
                daemon_log(LOG_ERR, "signal(SIGTSTP, SIG_IGN) failed: %s", strerror(errno));
                goto fail;
            }

            dpid = getpid();
            if (atomic_write(pipe_fds[1], &dpid, sizeof(dpid)) != sizeof(dpid)) {
                daemon_log(LOG_ERR, "write() failed: %s", strerror(errno));
                goto fail;
            }

            if (close(pipe_fds[1]) < 0) {
                daemon_log(LOG_ERR, "close() failed: %s", strerror(errno));
                goto fail;
            }

            return 0;

        } else {
            /* Second father */
            close(pipe_fds[1]);
            _exit(0);
        }

    fail:
        dpid = (pid_t) -1;

        if (atomic_write(pipe_fds[1], &dpid, sizeof(dpid)) != sizeof(dpid))
            daemon_log(LOG_ERR, "Failed to write error PID: %s", strerror(errno));

        close(pipe_fds[1]);
        _exit(0);

    } else {
        /* First father */
        pid_t dpid;

        close(pipe_fds[1]);

        if (waitpid(pid, NULL, WUNTRACED) < 0) {
            saved_errno = errno;
            close(pipe_fds[0]);
            sigaction(SIGCHLD, &sa_old, NULL);
            sigprocmask(SIG_SETMASK, &ss_old, NULL);
            errno = saved_errno;
            return -1;
        }

        sigprocmask(SIG_SETMASK, &ss_old, NULL);
        sigaction(SIGCHLD, &sa_old, NULL);

        if (atomic_read(pipe_fds[0], &dpid, sizeof(dpid)) != sizeof(dpid)) {
            daemon_log(LOG_ERR, "Failed to read daemon PID.");
            dpid = (pid_t) -1;
            errno = EINVAL;
        } else if (dpid == (pid_t) -1)
            errno = EIO;

        saved_errno = errno;
        close(pipe_fds[0]);
        errno = saved_errno;

        return dpid;
    }
}

int daemon_retval_init(void) {

    if (_daemon_retval_pipe[0] < 0 || _daemon_retval_pipe[1] < 0) {

        if (pipe(_daemon_retval_pipe) < 0) {
            daemon_log(LOG_ERR, "pipe(): %s", strerror(errno));
            return -1;
        }
    }

    return 0;
}

void daemon_retval_done(void) {
    int saved_errno = errno;

    if (_daemon_retval_pipe[0] >= 0)
        close(_daemon_retval_pipe[0]);

    if (_daemon_retval_pipe[1] >= 0)
        close(_daemon_retval_pipe[1]);

    _daemon_retval_pipe[0] = _daemon_retval_pipe[1] = -1;

    errno = saved_errno;
}

int daemon_retval_send(int i) {
    ssize_t r;

    if (_daemon_retval_pipe[1] < 0) {
        errno = EINVAL;
        return -1;
    }

    r = atomic_write(_daemon_retval_pipe[1], &i, sizeof(i));

    daemon_retval_done();

    if (r != sizeof(i)) {

        if (r < 0)
            daemon_log(LOG_ERR, "write() failed while writing return value to pipe: %s", strerror(errno));
        else {
            daemon_log(LOG_ERR, "write() too short while writing return value from pipe");
            errno = EINVAL;
        }

        return -1;
    }

    return 0;
}

int daemon_retval_wait(int timeout) {
    ssize_t r;
    int i;

    if (timeout > 0) {
        struct timeval tv;
        int s;
        fd_set fds;

        tv.tv_sec = timeout;
        tv.tv_usec = 0;

        FD_ZERO(&fds);
        FD_SET(_daemon_retval_pipe[0], &fds);

        if ((s = select(FD_SETSIZE, &fds, 0, 0, &tv)) != 1) {

            if (s < 0)
                daemon_log(LOG_ERR, "select() failed while waiting for return value: %s", strerror(errno));
            else {
                errno = ETIMEDOUT;
                daemon_log(LOG_ERR, "Timeout reached while wating for return value");
            }

            return -1;
        }
    }

    if ((r = atomic_read(_daemon_retval_pipe[0], &i, sizeof(i))) != sizeof(i)) {

        if (r < 0)
            daemon_log(LOG_ERR, "read() failed while reading return value from pipe: %s", strerror(errno));
        else if (r == 0) {
            daemon_log(LOG_ERR, "read() failed with EOF while reading return value from pipe.");
            errno = EINVAL;
        } else if (r > 0) {
            daemon_log(LOG_ERR, "read() too short while reading return value from pipe.");
            errno = EINVAL;
        }

        return -1;
    }

    daemon_retval_done();

    return i;
}

int daemon_close_all(int except_fd, ...) {
    va_list ap;
    int n = 0, i, r;
    int *p;
    int saved_errno;

    va_start(ap, except_fd);

    if (except_fd >= 0)
        for (n = 1; va_arg(ap, int) >= 0; n++)
            ;

    va_end(ap);

    if (!(p = malloc(sizeof(int) * (n+1))))
        return -1;

    va_start(ap, except_fd);

    i = 0;
    if (except_fd >= 0) {
        int fd;
        p[i++] = except_fd;

        while ((fd = va_arg(ap, int)) >= 0)
            p[i++] = fd;
    }
    p[i] = -1;

    va_end(ap);

    r = daemon_close_allv(p);

    saved_errno = errno;
    free(p);
    errno = saved_errno;

    return r;
}

/** Same as daemon_close_all but takes an array of fds, terminated by -1 */
int daemon_close_allv(const int except_fds[]) {
    struct rlimit rl;
    int fd, maxfd;

#ifdef __linux__
    int saved_errno;

    DIR *d;

    if ((d = opendir("/proc/self/fd"))) {

        struct dirent *de;

        while ((de = readdir(d))) {
            int found;
            long l;
            char *e = NULL;
            int i;

            if (de->d_name[0] == '.')
                continue;

            errno = 0;
            l = strtol(de->d_name, &e, 10);
            if (errno != 0 || !e || *e) {
                closedir(d);
                errno = EINVAL;
                return -1;
            }

            fd = (int) l;

            if ((long) fd != l) {
                closedir(d);
                errno = EINVAL;
                return -1;
            }

            if (fd < 3)
                continue;

            if (fd == dirfd(d))
                continue;

            if (fd == _daemon_retval_pipe[1])
                continue;

            found = 0;
            for (i = 0; except_fds[i] >= 0; i++)
                if (except_fds[i] == fd) {
                    found = 1;
                    break;
                }

            if (found)
                continue;

            if (close(fd) < 0) {
                saved_errno = errno;
                closedir(d);
                errno = saved_errno;

                return -1;
            }

            if (fd == _daemon_retval_pipe[0])
                _daemon_retval_pipe[0] = -1;    /* mark as closed */
        }

        closedir(d);
        return 0;
    }

#endif

    if (getrlimit(RLIMIT_NOFILE, &rl) > 0)
        maxfd = (int) rl.rlim_max;
    else
        maxfd = sysconf(_SC_OPEN_MAX);

    for (fd = 3; fd < maxfd; fd++) {
        int i, found;

        if (fd == _daemon_retval_pipe[1])
            continue;

        found = 0;
        for (i = 0; except_fds[i] >= 0; i++)
            if (except_fds[i] == fd) {
                found = 1;
                break;
            }

        if (found)
            continue;

        if (close(fd) < 0 && errno != EBADF)
            return -1;

        if (fd == _daemon_retval_pipe[0])
            _daemon_retval_pipe[0] = -1;        /* mark as closed */
    }

    return 0;
}

int daemon_unblock_sigs(int except, ...) {
    va_list ap;
    int n = 0, i, r;
    int *p;
    int saved_errno;

    va_start(ap, except);

    if (except >= 1)
        for (n = 1; va_arg(ap, int) >= 0; n++)
            ;

    va_end(ap);

    if (!(p = malloc(sizeof(int) * (n+1))))
        return -1;

    va_start(ap, except);

    i = 0;
    if (except >= 1) {
        int sig;
        p[i++] = except;

        while ((sig = va_arg(ap, int)) >= 0)
            p[i++] = sig;
    }
    p[i] = -1;

    va_end(ap);

    r = daemon_unblock_sigsv(p);

    saved_errno = errno;
    free(p);
    errno = saved_errno;

    return r;
}

int daemon_unblock_sigsv(const int except[]) {
    int i;
    sigset_t ss;

    if (sigemptyset(&ss) < 0)
        return -1;

    for (i = 0; except[i] > 0; i++)
        if (sigaddset(&ss, except[i]) < 0)
            return -1;

    return sigprocmask(SIG_SETMASK, &ss, NULL);
}

int daemon_reset_sigs(int except, ...) {
    va_list ap;
    int n = 0, i, r;
    int *p;
    int saved_errno;

    va_start(ap, except);

    if (except >= 1)
        for (n = 1; va_arg(ap, int) >= 0; n++)
            ;

    va_end(ap);

    if (!(p = malloc(sizeof(int) * (n+1))))
        return -1;

    va_start(ap, except);

    i = 0;
    if (except >= 1) {
        int sig;
        p[i++] = except;

        while ((sig = va_arg(ap, int)) >= 0)
            p[i++] = sig;
    }
    p[i] = -1;

    va_end(ap);

    r = daemon_reset_sigsv(p);

    saved_errno = errno;
    free(p);
    errno = saved_errno;

    return r;
}

int daemon_reset_sigsv(const int except[]) {
    int sig;

    for (sig = 1; sig < SIGNAL_UPPER_BOUND; sig++) {
        int reset = 1;

        switch (sig) {
            case SIGKILL:
            case SIGSTOP:
                reset = 0;
                break;

            default: {
                int i;

                for (i = 0; except[i] > 0; i++) {
                    if (sig == except[i]) {
                        reset = 0;
                        break;
                    }
                }
            }
        }

        if (reset) {
            struct sigaction sa;

            memset(&sa, 0, sizeof(sa));
            sa.sa_handler = SIG_DFL;

            /* On Linux the first two RT signals are reserved by
             * glibc, and sigaction() will return EINVAL for them. */
            if ((sigaction(sig, &sa, NULL) < 0))
                if (errno != EINVAL)
                    return -1;
        }
    }

    return 0;
}