/*

   daemoninze.c - functions for properly daemonising an application

   Copyright (C) 2014-2015 Arthur de Jong

   This library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   This library 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

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with this library; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

   02110-1301 USA

*/

#include "config.h"

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <string.h>

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#ifdef HAVE_PTHREAD_H

#include <pthread.h>

#endif /* HAVE_PTHREAD_H */

#include "daemonize.h"

#include "log.h"

/* the write end of a pipe that is used to signal the fact that the child

   process has finished initialising (see daemonize_daemon() and

   daemonize_ready() for details) */

static int daemonizefd = -1;

void daemonize_closefds(void)

{

  int i;

  /* close all file descriptors (except stdin/out/err) */

  i = sysconf(_SC_OPEN_MAX) - 1;

  /* if the system does not have OPEN_MAX just close the first 32 and

     hope we closed enough */

  if (i < 0)

    i = 32;

  for (; i > 3; i--)

    close(i);

}

void daemonize_redirect_stdio(void)

{

  /* close stdin, stdout and stderr */

  (void)close(0);   /* stdin */

  (void)close(1);   /* stdout */

  (void)close(2);   /* stderr */

  /* reconnect to /dev/null */

  (void)open("/dev/null", O_RDWR);  /* stdin, fd=0 */

  (void)dup(0);     /* stdout, fd=1 */

  (void)dup(0);     /* stderr, fd=2 */

}

/* try to fill the buffer until EOF or error */

static int read_response(int fd, char *buffer, size_t bufsz)

{

  int rc;

  size_t r = 0;

  while (r < bufsz)

  {

    rc = read(fd, buffer + r, bufsz - r);

    if (rc == 0)

      break;

    else if (rc > 0)

      r += rc;

    else if ((errno == EINTR) || (errno == EAGAIN))

      continue; /* ignore these errors and try again */

    else

    {

      log_log(LOG_ERR, "read_response(): read() failed: %s", strerror(errno));

      return -1;

    }

  }

  return r;

}

/* The parent process calling daemonize_daemon() will end up here on success */

static int wait_for_response(int fd)

{

  int i, l, rc;

  char buffer[1024];

  /* read return code */

  errno = 0;

  i = read_response(fd, (void *)&rc, sizeof(int));

  log_log(LOG_DEBUG, "DEBUG: wait_for_response(): i=%d, rc=%d", i, rc);

  if (i != sizeof(int))

  {

    log_log(LOG_ERR, "wait_for_response(): read_response() returned %d (expected %d)",

            i, (int)sizeof(int));

    if (errno == 0)

#ifdef ENODATA

      errno = ENODATA;

#else

      errno = ENOATTR;

#endif

    return -1;

  }

  /* read string length */

  i = read_response(fd, (void *)&l, sizeof(int));

  log_log(LOG_DEBUG, "DEBUG: wait_for_response(): i=%d, l=%d", i, l);

  if ((i != sizeof(int)) || (l <= 0))

    _exit(rc);

  /* read string */

  if ((size_t)l > (sizeof(buffer) - 1))

    l = sizeof(buffer) - 1;

  i = read_response(fd, buffer, l);

  buffer[l] = '\0';

  if (i == l)

    fprintf(stderr, "%s", buffer);

  _exit(rc);

}

static void closefd(void)

{

  if (daemonizefd >= 0)

  {

    close(daemonizefd);

    daemonizefd = -1;

  }

}

int daemonize_daemon(void)

{

  int pipefds[2];

  int i;

  /* set up a pipe for communication */

  if (pipe(pipefds) < 0)

  {

    log_log(LOG_ERR, "pipe() failed: %s", strerror(errno));

    return -1;

  }

  /* set O_NONBLOCK on the write end to ensure that a call to

     daemonize_ready() will not lock the application */

  if ((i = fcntl(pipefds[1], F_GETFL, 0)) < 0)

  {

    log_log(LOG_ERR, "fcntl() failed: %s", strerror(errno));

    close(pipefds[0]);

    close(pipefds[1]);

    return -1;

  }

  if (fcntl(pipefds[1], F_SETFL, i | O_NONBLOCK) < 0)

  {

    log_log(LOG_ERR, "fcntl() failed: %s", strerror(errno));

    close(pipefds[0]);

    close(pipefds[1]);

    return -1;

  }

  /* fork() and exit() to detach from the parent process */

  switch (fork())

  {

    case 0:

      /* we are the child, close read end of pipe */

      close(pipefds[0]);

      break;

    case -1:

      /* we are the parent, but have an error */

      log_log(LOG_ERR, "fork() failed: %s", strerror(errno));

      close(pipefds[0]);

      close(pipefds[1]);

      return -1;

    default:

      /* we are the parent, close write end and wait for information */

      close(pipefds[1]);

      return wait_for_response(pipefds[0]);

  }

  /* become process leader */

  if (setsid() < 0)

  {

    log_log(LOG_ERR, "setsid() failed: %s", strerror(errno));

    close(pipefds[1]);

    _exit(EXIT_FAILURE);

  }

  /* fork again so we cannot allocate a pty */

  switch (fork())

  {

    case 0:

      /* we are the child */

      break;

    case -1:

      /* we are the parent, but have an error */

      log_log(LOG_ERR, "fork() failed: %s", strerror(errno));

      close(pipefds[1]);

      _exit(EXIT_FAILURE);

    default:

      /* we are the parent and we're done */

      close(pipefds[1]);

      _exit(EXIT_SUCCESS);

  }

  daemonizefd = pipefds[1];

  /* close the file descriptor on exec (ignore errors) */

  fcntl(daemonizefd, F_SETFD, FD_CLOEXEC);

#ifdef HAVE_PTHREAD_ATFORK

  /* handle any other forks by closing daemonizefd first */

  (void)pthread_atfork(NULL, NULL, closefd);

#endif /* HAVE_PTHREAD_ATFORK */

  return 0;

}

void daemonize_ready(int status, const char *message)

{

  int l;

  if (daemonizefd >= 0)

  {

    /* we ignore any errors writing */

    (void)write(daemonizefd, &status, sizeof(int));

    if ((message == NULL) || (message[0] == '\0'))

    {

      l = 0;

      (void)write(daemonizefd, &l, sizeof(int));

    }

    else

    {

      l = strlen(message);

      (void)write(daemonizefd, &l, sizeof(int));

      (void)write(daemonizefd, message, l);

    }

    (void)close(daemonizefd);

    daemonizefd = -1;

  }

}