/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-spawn.c Wrapper around fork/exec

 * 

 * Copyright (C) 2002, 2003, 2004  Red Hat, Inc.

 * Copyright (C) 2003 CodeFactory AB

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 * 

 * 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

 *

 */

#include "dbus-spawn.h"

#include "dbus-sysdeps.h"

#include "dbus-internals.h"

#include "dbus-test.h"

#include "dbus-protocol.h"

#include <unistd.h>

#include <fcntl.h>

#ifndef __SYMBIAN32__

#include <signal.h>

#endif

#include <sys/wait.h>

#include <errno.h>

#include <stdlib.h>

#include <spawn.h>

#include <pthread.h> 

/**

 * @addtogroup DBusInternalsUtils

 * @{

 */

/*

 * I'm pretty sure this whole spawn file could be made simpler,

 * if you thought about it a bit.

 */

/**

 * Enumeration for status of a read()

 */

typedef enum

{

  READ_STATUS_OK,    /**< Read succeeded */

  READ_STATUS_ERROR, /**< Some kind of error */

  READ_STATUS_EOF    /**< EOF returned */

} ReadStatus;

static ReadStatus

read_ints (int        fd,

	   int       *buf,

	   int        n_ints_in_buf,

	   int       *n_ints_read,

	   DBusError *error)

{

  size_t bytes = 0;    

  ReadStatus retval;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  retval = READ_STATUS_OK;

  while (TRUE)

    {

      size_t chunk;

      size_t to_read;

      to_read = sizeof (int) * n_ints_in_buf - bytes;

      if (to_read == 0)

        break;

    again:

      chunk = read (fd,

                    ((char*)buf) + bytes,

                    to_read);

      if (chunk < 0 && errno == EINTR)

        goto again;

      if (chunk < 0)

        {

          dbus_set_error (error,

			  DBUS_ERROR_SPAWN_FAILED,

			  "Failed to read from child pipe (%s)",

			  _dbus_strerror (errno));

          retval = READ_STATUS_ERROR;

          break;

        }

      else if (chunk == 0)

        {

          retval = READ_STATUS_EOF;

          break; /* EOF */

        }

      else /* chunk > 0 */

	bytes += chunk;

    }

  *n_ints_read = (int)(bytes / sizeof(int));

  return retval;

}

static ReadStatus

read_pid (int        fd,

          pid_t     *buf,

          DBusError *error)

{

  size_t bytes = 0;    

  ReadStatus retval;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  retval = READ_STATUS_OK;

  while (TRUE)

    {

      size_t chunk;    

      size_t to_read;

      to_read = sizeof (pid_t) - bytes;

      if (to_read == 0)

        break;

    again:

      chunk = read (fd,

                    ((char*)buf) + bytes,

                    to_read);

      if (chunk < 0 && errno == EINTR)

        goto again;

      if (chunk < 0)

        {

          dbus_set_error (error,

			  DBUS_ERROR_SPAWN_FAILED,

			  "Failed to read from child pipe (%s)",

			  _dbus_strerror (errno));

          retval = READ_STATUS_ERROR;

          break;

        }

      else if (chunk == 0)

        {

          retval = READ_STATUS_EOF;

          break; /* EOF */

        }

      else /* chunk > 0 */

	bytes += chunk;

    }

  return retval;

}

/* The implementation uses an intermediate child between the main process

 * and the grandchild. The grandchild is our spawned process. The intermediate

 * child is a babysitter process; it keeps track of when the grandchild

 * exits/crashes, and reaps the grandchild.

 */

/* Messages from children to parents */

enum

{

  CHILD_EXITED,            /* This message is followed by the exit status int */

  CHILD_FORK_FAILED,       /* Followed by errno */

  CHILD_EXEC_FAILED,       /* Followed by errno */

  CHILD_PID                /* Followed by pid_t */

};

/**

 * Babysitter implementation details

 */

struct DBusBabysitter

{

  int refcount; /**< Reference count */

  char *executable; /**< executable name to use in error messages */

  int socket_to_babysitter; /**< Connection to the babysitter process */

  int error_pipe_from_child; /**< Connection to the process that does the exec() */

  pid_t sitter_pid;  /**< PID Of the babysitter */

  pid_t grandchild_pid; /**< PID of the grandchild */

  DBusWatchList *watches; /**< Watches */

  DBusWatch *error_watch; /**< Error pipe watch */

  DBusWatch *sitter_watch; /**< Sitter pipe watch */

  int errnum; /**< Error number */

  int status; /**< Exit status code */

  unsigned int have_child_status : 1; /**< True if child status has been reaped */

  unsigned int have_fork_errnum : 1; /**< True if we have an error code from fork() */

  unsigned int have_exec_errnum : 1; /**< True if we have an error code from exec() */

};

static DBusBabysitter*

_dbus_babysitter_new (void)

{

  DBusBabysitter *sitter;

  sitter = dbus_new0 (DBusBabysitter, 1);

  if (sitter == NULL)

    return NULL;

  sitter->refcount = 1;

  sitter->socket_to_babysitter = -1;

  sitter->error_pipe_from_child = -1;

  sitter->sitter_pid = -1;

  sitter->grandchild_pid = -1;

  sitter->watches = _dbus_watch_list_new ();

  if (sitter->watches == NULL)

    goto failed;

  return sitter;

 failed:

  _dbus_babysitter_unref (sitter);

  return NULL;

}

/**

 * Increment the reference count on the babysitter object.

 *

 * @param sitter the babysitter

 * @returns the babysitter

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

DBusBabysitter *

_dbus_babysitter_ref (DBusBabysitter *sitter)

{

  _dbus_assert (sitter != NULL);

  _dbus_assert (sitter->refcount > 0);

  sitter->refcount += 1;

  return sitter;

}

/**

 * Decrement the reference count on the babysitter object.

 * When the reference count of the babysitter object reaches

 * zero, the babysitter is killed and the child that was being

 * babysat gets emancipated.

 *

 * @param sitter the babysitter

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

_dbus_babysitter_unref (DBusBabysitter *sitter)

{

  _dbus_assert (sitter != NULL);

  _dbus_assert (sitter->refcount > 0);

  sitter->refcount -= 1;

  if (sitter->refcount == 0)

    {      

      if (sitter->socket_to_babysitter >= 0)

        {

          /* If we haven't forked other babysitters

           * since this babysitter and socket were

           * created then this close will cause the

           * babysitter to wake up from poll with

           * a hangup and then the babysitter will

           * quit itself.

           */

          _dbus_close_socket (sitter->socket_to_babysitter, NULL);

          sitter->socket_to_babysitter = -1;

        }

      if (sitter->error_pipe_from_child >= 0)

        {

          _dbus_close_socket (sitter->error_pipe_from_child, NULL);

          sitter->error_pipe_from_child = -1;

        }

      if (sitter->sitter_pid > 0)

        {

          int status;

          int ret;

          /* It's possible the babysitter died on its own above 

           * from the close, or was killed randomly

           * by some other process, so first try to reap it

           */

          ret = waitpid (sitter->sitter_pid, &status, WNOHANG);

          /* If we couldn't reap the child then kill it, and

           * try again

           */

#ifndef __SYMBIAN32__           

          if (ret == 0)          

            kill (sitter->sitter_pid, SIGKILL);

#endif          

        again:

          if (ret == 0)

            ret = waitpid (sitter->sitter_pid, &status, 0);

          if (ret < 0)

            {

              if (errno == EINTR)

                goto again;

              else if (errno == ECHILD)

                _dbus_warn ("Babysitter process not available to be reaped; should not happen\n");

              else

                _dbus_warn ("Unexpected error %d in waitpid() for babysitter: %s\n",

                            errno, _dbus_strerror (errno));

            }

          else

            {

              _dbus_verbose ("Reaped %ld, waiting for babysitter %ld\n",

                             (long) ret, (long) sitter->sitter_pid);

              if (WIFEXITED (sitter->status))

                _dbus_verbose ("Babysitter exited with status %d\n",

                               WEXITSTATUS (sitter->status));

              else if (WIFSIGNALED (sitter->status))

                _dbus_verbose ("Babysitter received signal %d\n",

                               WTERMSIG (sitter->status));

              else

                _dbus_verbose ("Babysitter exited abnormally\n");

            }

          sitter->sitter_pid = -1;

        }

      if (sitter->error_watch)

        {

          _dbus_watch_invalidate (sitter->error_watch);

          _dbus_watch_unref (sitter->error_watch);

          sitter->error_watch = NULL;

        }

      if (sitter->sitter_watch)

        {

          _dbus_watch_invalidate (sitter->sitter_watch);

          _dbus_watch_unref (sitter->sitter_watch);

          sitter->sitter_watch = NULL;

        }

      if (sitter->watches)

        _dbus_watch_list_free (sitter->watches);

      dbus_free (sitter->executable);

      dbus_free (sitter);

    }

}

static ReadStatus

read_data (DBusBabysitter *sitter,

           int             fd)

{

  int what;

  int got;

  DBusError error;

  ReadStatus r;

  dbus_error_init (&error);

  r = read_ints (fd, &what, 1, &got, &error);

  switch (r)

    {

    case READ_STATUS_ERROR:

      _dbus_warn ("Failed to read data from fd %d: %s\n", fd, error.message);

      dbus_error_free (&error);

      return r;

    case READ_STATUS_EOF:

      return r;

    case READ_STATUS_OK:

      break;

    }

  if (got == 1)

    {

      switch (what)

        {

        case CHILD_EXITED:

        case CHILD_FORK_FAILED:

        case CHILD_EXEC_FAILED:

          {

            int arg;

            r = read_ints (fd, &arg, 1, &got, &error);

            switch (r)

              {

              case READ_STATUS_ERROR:

                _dbus_warn ("Failed to read arg from fd %d: %s\n", fd, error.message);

                dbus_error_free (&error);

                return r;

              case READ_STATUS_EOF:

                return r;

              case READ_STATUS_OK:

                break;

              }

            if (got == 1)

              {

                if (what == CHILD_EXITED)

                  {

                    sitter->have_child_status = TRUE;

                    sitter->status = arg;

                    _dbus_verbose ("recorded child status exited = %d signaled = %d exitstatus = %d termsig = %d\n",

                                   WIFEXITED (sitter->status), WIFSIGNALED (sitter->status),

                                   WEXITSTATUS (sitter->status), WTERMSIG (sitter->status));

                  }

                else if (what == CHILD_FORK_FAILED)

                  {

                    sitter->have_fork_errnum = TRUE;

                    sitter->errnum = arg;

                    _dbus_verbose ("recorded fork errnum %d\n", sitter->errnum);

                  }

                else if (what == CHILD_EXEC_FAILED)

                  {

                    sitter->have_exec_errnum = TRUE;

                    sitter->errnum = arg;

                    _dbus_verbose ("recorded exec errnum %d\n", sitter->errnum);

                  }

              }

          }

          break;

        case CHILD_PID:

          {

            pid_t pid = -1;

            r = read_pid (fd, &pid, &error);

            switch (r)

              {

              case READ_STATUS_ERROR:

                _dbus_warn ("Failed to read PID from fd %d: %s\n", fd, error.message);

                dbus_error_free (&error);

                return r;

              case READ_STATUS_EOF:

                return r;

              case READ_STATUS_OK:

                break;

              }

            sitter->grandchild_pid = pid;

            _dbus_verbose ("recorded grandchild pid %d\n", sitter->grandchild_pid);

          }

          break;

        default:

          _dbus_warn ("Unknown message received from babysitter process\n");

          break;

        }

    }

  return r;

}

static void

close_socket_to_babysitter (DBusBabysitter *sitter)

{

  _dbus_verbose ("Closing babysitter\n");

  _dbus_close_socket (sitter->socket_to_babysitter, NULL);

  sitter->socket_to_babysitter = -1;

}

static void

close_error_pipe_from_child (DBusBabysitter *sitter)

{

  _dbus_verbose ("Closing child error\n");

  _dbus_close_socket (sitter->error_pipe_from_child, NULL);

  sitter->error_pipe_from_child = -1;

}

static void

handle_babysitter_socket (DBusBabysitter *sitter,

                          int             revents)

{

  /* Even if we have POLLHUP, we want to keep reading

   * data until POLLIN goes away; so this function only

   * looks at HUP/ERR if no IN is set.

   */

  if (revents & _DBUS_POLLIN)

    {

      _dbus_verbose ("Reading data from babysitter\n");

      if (read_data (sitter, sitter->socket_to_babysitter) != READ_STATUS_OK)

        close_socket_to_babysitter (sitter);

    }

  else if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))

    {

      close_socket_to_babysitter (sitter);

    }

}

static void

handle_error_pipe (DBusBabysitter *sitter,

                   int             revents)

{

  if (revents & _DBUS_POLLIN)

    {

      _dbus_verbose ("Reading data from child error\n");

      if (read_data (sitter, sitter->error_pipe_from_child) != READ_STATUS_OK)

        close_error_pipe_from_child (sitter);

    }

  else if (revents & (_DBUS_POLLERR | _DBUS_POLLHUP))

    {

      close_error_pipe_from_child (sitter);