Пример #1
0
/**
 * Spawns a new process.
 *
 * On Unix platforms, the child_setup function is passed the given
 * user_data and is run in the child after fork() but before calling exec().
 * This can be used to change uid, resource limits and so on.
 * On Windows, this functionality does not fit the multi-processing model
 * (Windows does the equivalent of fork() and exec() in a single API call),
 * and the child_setup function and its user_data are ignored.
 *
 * Also creates a "babysitter" which tracks the status of the
 * child process, advising the parent if the child exits.
 * If the spawn fails, no babysitter is created.
 * If sitter_p is #NULL, no babysitter is kept.
 *
 * @param sitter_p return location for babysitter or #NULL
 * @param log_name the name under which to log messages about this process being spawned
 * @param argv the executable and arguments
 * @param env the environment, or #NULL to copy the parent's
 * @param child_setup function to call in child pre-exec()
 * @param user_data user data for setup function
 * @param error error object to be filled in if function fails
 * @returns #TRUE on success, #FALSE if error is filled in
 */
dbus_bool_t
_dbus_spawn_async_with_babysitter (DBusBabysitter          **sitter_p,
                                   const char               *log_name,
                                   char             * const *argv,
                                   char                    **env,
                                   DBusSpawnFlags            flags,
                                   DBusSpawnChildSetupFunc   child_setup,
                                   void                     *user_data,
                                   DBusError                *error)
{
  DBusBabysitter *sitter;
  int child_err_report_pipe[2] = { -1, -1 };
  DBusSocket babysitter_pipe[2] = { DBUS_SOCKET_INIT, DBUS_SOCKET_INIT };
  pid_t pid;
#ifdef HAVE_SYSTEMD
  int fd_out = -1;
  int fd_err = -1;
#endif
  
  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  _dbus_assert (argv[0] != NULL);

  if (sitter_p != NULL)
    *sitter_p = NULL;

  sitter = NULL;

  sitter = _dbus_babysitter_new ();
  if (sitter == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      return FALSE;
    }

  sitter->log_name = _dbus_strdup (log_name);
  if (sitter->log_name == NULL && log_name != NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }

  if (sitter->log_name == NULL)
    sitter->log_name = _dbus_strdup (argv[0]);

  if (sitter->log_name == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
  
  if (!make_pipe (child_err_report_pipe, error))
    goto cleanup_and_fail;

  if (!_dbus_socketpair (&babysitter_pipe[0], &babysitter_pipe[1], TRUE, error))
    goto cleanup_and_fail;

  /* Setting up the babysitter is only useful in the parent,
   * but we don't want to run out of memory and fail
   * after we've already forked, since then we'd leak
   * child processes everywhere.
   */
  sitter->error_watch = _dbus_watch_new (child_err_report_pipe[READ_END],
                                         DBUS_WATCH_READABLE,
                                         TRUE, handle_watch, sitter, NULL);
  if (sitter->error_watch == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
        
  if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->error_watch))
    {
      /* we need to free it early so the destructor won't try to remove it
       * without it having been added, which DBusLoop doesn't allow */
      _dbus_watch_invalidate (sitter->error_watch);
      _dbus_watch_unref (sitter->error_watch);
      sitter->error_watch = NULL;

      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
      
  sitter->sitter_watch = _dbus_watch_new (babysitter_pipe[0].fd,
                                          DBUS_WATCH_READABLE,
                                          TRUE, handle_watch, sitter, NULL);
  if (sitter->sitter_watch == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
      
  if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->sitter_watch))
    {
      /* we need to free it early so the destructor won't try to remove it
       * without it having been added, which DBusLoop doesn't allow */
      _dbus_watch_invalidate (sitter->sitter_watch);
      _dbus_watch_unref (sitter->sitter_watch);
      sitter->sitter_watch = NULL;

      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

#ifdef HAVE_SYSTEMD
  if (flags & DBUS_SPAWN_REDIRECT_OUTPUT)
    {
      /* This may fail, but it's not critical.
       * In particular, if we were compiled with journald support but are now
       * running on a non-systemd system, this is going to fail, so we
       * have to cope gracefully. */
      fd_out = sd_journal_stream_fd (sitter->log_name, LOG_INFO, FALSE);
      fd_err = sd_journal_stream_fd (sitter->log_name, LOG_WARNING, FALSE);
    }
#endif

  pid = fork ();
  
  if (pid < 0)
    {
      dbus_set_error (error,
		      DBUS_ERROR_SPAWN_FORK_FAILED,
		      "Failed to fork (%s)",
		      _dbus_strerror (errno));
      goto cleanup_and_fail;
    }
  else if (pid == 0)
    {
      /* Immediate child, this is the babysitter process. */
      int grandchild_pid;
      
      /* Be sure we crash if the parent exits
       * and we write to the err_report_pipe
       */
      signal (SIGPIPE, SIG_DFL);

      /* Close the parent's end of the pipes. */
      close_and_invalidate (&child_err_report_pipe[READ_END]);
      close_and_invalidate (&babysitter_pipe[0].fd);
      
      /* Create the child that will exec () */
      grandchild_pid = fork ();
      
      if (grandchild_pid < 0)
	{
	  write_err_and_exit (babysitter_pipe[1].fd,
			      CHILD_FORK_FAILED);
          _dbus_assert_not_reached ("Got to code after write_err_and_exit()");
	}
      else if (grandchild_pid == 0)
      {
#ifdef __linux__
          int fd = -1;

#ifdef O_CLOEXEC
          fd = open ("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
#endif

          if (fd < 0)
            {
              fd = open ("/proc/self/oom_score_adj", O_WRONLY);
              _dbus_fd_set_close_on_exec (fd);
            }

          if (fd >= 0)
            {
              if (write (fd, "0", sizeof (char)) < 0)
                _dbus_warn ("writing oom_score_adj error: %s", strerror (errno));
              _dbus_close (fd, NULL);
            }
#endif
          /* Go back to ignoring SIGPIPE, since it's evil
           */
          signal (SIGPIPE, SIG_IGN);

          close_and_invalidate (&babysitter_pipe[1].fd);
#ifdef HAVE_SYSTEMD
	  /* log to systemd journal if possible */
	  if (fd_out >= 0)
            dup2 (fd_out, STDOUT_FILENO);
	  if (fd_err >= 0)
            dup2 (fd_err, STDERR_FILENO);
          close_and_invalidate (&fd_out);
          close_and_invalidate (&fd_err);
#endif
	  do_exec (child_err_report_pipe[WRITE_END],
		   argv,
		   env,
		   child_setup, user_data);
          _dbus_assert_not_reached ("Got to code after exec() - should have exited on error");
	}
      else
	{
          close_and_invalidate (&child_err_report_pipe[WRITE_END]);
#ifdef HAVE_SYSTEMD
          close_and_invalidate (&fd_out);
          close_and_invalidate (&fd_err);
#endif
          babysit (grandchild_pid, babysitter_pipe[1].fd);
          _dbus_assert_not_reached ("Got to code after babysit()");
	}
    }
  else
    {      
      /* Close the uncared-about ends of the pipes */
      close_and_invalidate (&child_err_report_pipe[WRITE_END]);
      close_and_invalidate (&babysitter_pipe[1].fd);
#ifdef HAVE_SYSTEMD
      close_and_invalidate (&fd_out);
      close_and_invalidate (&fd_err);
#endif

      sitter->socket_to_babysitter = babysitter_pipe[0];
      babysitter_pipe[0].fd = -1;
      
      sitter->error_pipe_from_child = child_err_report_pipe[READ_END];
      child_err_report_pipe[READ_END] = -1;

      sitter->sitter_pid = pid;

      if (sitter_p != NULL)
        *sitter_p = sitter;
      else
        _dbus_babysitter_unref (sitter);

      dbus_free_string_array (env);

      _DBUS_ASSERT_ERROR_IS_CLEAR (error);
      
      return TRUE;
    }

 cleanup_and_fail:

  _DBUS_ASSERT_ERROR_IS_SET (error);
  
  close_and_invalidate (&child_err_report_pipe[READ_END]);
  close_and_invalidate (&child_err_report_pipe[WRITE_END]);
  close_and_invalidate (&babysitter_pipe[0].fd);
  close_and_invalidate (&babysitter_pipe[1].fd);
#ifdef HAVE_SYSTEMD
  close_and_invalidate (&fd_out);
  close_and_invalidate (&fd_err);
#endif

  if (sitter != NULL)
    _dbus_babysitter_unref (sitter);
  
  return FALSE;
}
Пример #2
0
static int fork_child_async(const char* cmd, int* child_pid) {
	pid_t pid, grandchild_pid;
	int child_pid_report_pipe[2] = {-1, -1};
	int child_err_report_pipe[2] = {-1, -1};
	int null_dev;

	/* by default is assumed how command wasn't found */
	int ret = RUN_NOT_FOUND;

	errno = 0;
	if(pipe(child_pid_report_pipe) != 0) {
		E_WARNING(E_STRLOC ": pipe() failed with '%s'\n", strerror(errno));
		return RUN_PIPE_FAILED;
	}

	if(pipe(child_err_report_pipe) != 0) {
		E_WARNING(E_STRLOC ": pipe() failed with '%s'\n", strerror(errno));
		return RUN_PIPE_FAILED;
	}

	pid = fork();

	if(pid < 0) {
		E_WARNING(E_STRLOC ": fork() failed with '%s'\n", strerror(errno));
		return RUN_FORK_FAILED;
	} else if(pid == 0) {
		signal(SIGPIPE, SIG_DFL);

		close_and_invalidate(&child_pid_report_pipe[0]);
		close_and_invalidate(&child_err_report_pipe[0]);

		/* TODO stdin, stdout, stderr */

		grandchild_pid = fork();

		if(grandchild_pid < 0) {
			/* report -1 as returned value */
			write_int(child_pid_report_pipe[1], grandchild_pid);
			write_int(child_err_report_pipe[1], RUN_FORK_FAILED);
			_exit(1);
		} else if(grandchild_pid == 0) {
			/* 
			 * second child code is here; from now on every error
			 * is reported via pipe
			 */
			null_dev = open("/dev/null", O_RDWR);

			if(null_dev == -1) {
				write_int(child_pid_report_pipe[1], grandchild_pid);
				write_int(child_err_report_pipe[1], errno);
				_exit(1);
			}

			/* close on exec */
			fcntl(child_err_report_pipe[1], F_SETFD, FD_CLOEXEC);

			/* just send stdin, stdout, stderr to null dev */
			close(0); 
			dup(null_dev);

			close(1); 
			dup(null_dev);

			close(2); 
			dup(null_dev);

			exec_cmd(cmd, child_err_report_pipe[1]);
		} else {
			/* child (a grandchild parent) is here; report it's pid before normal exit */
			write_int(child_pid_report_pipe[1], grandchild_pid);
			close_and_invalidate(&child_err_report_pipe[1]);
			_exit(0);
		}
	} else {
		/* parent */
		int status, buf[2], n_ints = 0;

		close_and_invalidate(&child_pid_report_pipe[1]);
		close_and_invalidate(&child_err_report_pipe[1]);

		/* reap intermediate child */
		while(waitpid(pid, &status, 0) < 0) {
			if(errno == EINTR)
				continue;
			break;
		}

		if(!read_ints(child_err_report_pipe[0], buf, 2, &n_ints))
			goto fail;

		/* child signaled some error; inspect it and bail out */
		if(n_ints >= 2) {
			ret = convert_from_errno(buf[1], buf[0]);
			goto fail;
		}

		/* get pid from grandchild pid, this is the pid of actual forked program */
		n_ints = 0;
		if(!read_ints(child_pid_report_pipe[0], buf, 1, &n_ints)) {
			ret = RUN_PIPE_FAILED;
			goto fail;
		}

		if(n_ints < 1) {
			ret = RUN_PIPE_FAILED;
			goto fail;
		}

		if(child_pid)
			*child_pid = buf[0];

		close_and_invalidate(&child_err_report_pipe[0]);
		close_and_invalidate(&child_pid_report_pipe[0]);
		/* everything went fine */
		return 0;
	}

fail:
	/* we got some error in first child; reap it so it does not become a zombie */
	if(pid > 0) {
		while(waitpid(pid, NULL, 0) < 0) {
			if(errno != EINTR)
				break;
		}
	}

	close_and_invalidate(&child_pid_report_pipe[0]);
	close_and_invalidate(&child_pid_report_pipe[1]);
	close_and_invalidate(&child_err_report_pipe[0]);
	close_and_invalidate(&child_err_report_pipe[1]);

	return ret;
}
Пример #3
0
/**
 * Spawns a new process. The executable name and argv[0]
 * are the same, both are provided in argv[0]. The child_setup
 * function is passed the given user_data and is run in the child
 * just before calling exec().
 *
 * Also creates a "babysitter" which tracks the status of the
 * child process, advising the parent if the child exits.
 * If the spawn fails, no babysitter is created.
 * If sitter_p is #NULL, no babysitter is kept.
 *
 * @param sitter_p return location for babysitter or #NULL
 * @param argv the executable and arguments
 * @param env the environment (not used on unix yet)
 * @param child_setup function to call in child pre-exec()
 * @param user_data user data for setup function
 * @param error error object to be filled in if function fails
 * @returns #TRUE on success, #FALSE if error is filled in
 */
dbus_bool_t
_dbus_spawn_async_with_babysitter (DBusBabysitter          **sitter_p,
                                   char                    **argv,
                                   char                    **env,
                                   DBusSpawnChildSetupFunc   child_setup,
                                   void                     *user_data,
                                   DBusError                *error)
{
    DBusBabysitter *sitter;
    int child_err_report_pipe[2] = { -1, -1 };
    int babysitter_pipe[2] = { -1, -1 };
    pid_t pid;

    _DBUS_ASSERT_ERROR_IS_CLEAR (error);

    if (sitter_p != NULL)
        *sitter_p = NULL;

    sitter = NULL;

    sitter = _dbus_babysitter_new ();
    if (sitter == NULL)
    {
        dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
        return FALSE;
    }

    sitter->executable = _dbus_strdup (argv[0]);
    if (sitter->executable == NULL)
    {
        dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
        goto cleanup_and_fail;
    }

    if (!make_pipe (child_err_report_pipe, error))
        goto cleanup_and_fail;

    if (!_dbus_full_duplex_pipe (&babysitter_pipe[0], &babysitter_pipe[1], TRUE, error))
        goto cleanup_and_fail;

    /* Setting up the babysitter is only useful in the parent,
     * but we don't want to run out of memory and fail
     * after we've already forked, since then we'd leak
     * child processes everywhere.
     */
    sitter->error_watch = _dbus_watch_new (child_err_report_pipe[READ_END],
                                           DBUS_WATCH_READABLE,
                                           TRUE, handle_watch, sitter, NULL);
    if (sitter->error_watch == NULL)
    {
        dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
        goto cleanup_and_fail;
    }

    if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->error_watch))
    {
        /* we need to free it early so the destructor won't try to remove it
         * without it having been added, which DBusLoop doesn't allow */
        _dbus_watch_invalidate (sitter->error_watch);
        _dbus_watch_unref (sitter->error_watch);
        sitter->error_watch = NULL;

        dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
        goto cleanup_and_fail;
    }

    sitter->sitter_watch = _dbus_watch_new (babysitter_pipe[0],
                                            DBUS_WATCH_READABLE,
                                            TRUE, handle_watch, sitter, NULL);
    if (sitter->sitter_watch == NULL)
    {
        dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
        goto cleanup_and_fail;
    }

    if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->sitter_watch))
    {
        /* we need to free it early so the destructor won't try to remove it
         * without it having been added, which DBusLoop doesn't allow */
        _dbus_watch_invalidate (sitter->sitter_watch);
        _dbus_watch_unref (sitter->sitter_watch);
        sitter->sitter_watch = NULL;

        dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
        goto cleanup_and_fail;
    }

    _DBUS_ASSERT_ERROR_IS_CLEAR (error);

    pid = fork ();

    if (pid < 0)
    {
        dbus_set_error (error,
                        DBUS_ERROR_SPAWN_FORK_FAILED,
                        "Failed to fork (%s)",
                        _dbus_strerror (errno));
        goto cleanup_and_fail;
    }
    else if (pid == 0)
    {
        /* Immediate child, this is the babysitter process. */
        int grandchild_pid;

        /* Be sure we crash if the parent exits
         * and we write to the err_report_pipe
         */
        signal (SIGPIPE, SIG_DFL);

        /* Close the parent's end of the pipes. */
        close_and_invalidate (&child_err_report_pipe[READ_END]);
        close_and_invalidate (&babysitter_pipe[0]);

        /* Create the child that will exec () */
        grandchild_pid = fork ();

        if (grandchild_pid < 0)
        {
            write_err_and_exit (babysitter_pipe[1],
                                CHILD_FORK_FAILED);
            _dbus_assert_not_reached ("Got to code after write_err_and_exit()");
        }
        else if (grandchild_pid == 0)
        {
            do_exec (child_err_report_pipe[WRITE_END],
                     argv,
                     env,
                     child_setup, user_data);
            _dbus_assert_not_reached ("Got to code after exec() - should have exited on error");
        }
        else
        {
            babysit (grandchild_pid, babysitter_pipe[1]);
            _dbus_assert_not_reached ("Got to code after babysit()");
        }
    }
    else
    {
        /* Close the uncared-about ends of the pipes */
        close_and_invalidate (&child_err_report_pipe[WRITE_END]);
        close_and_invalidate (&babysitter_pipe[1]);

        sitter->socket_to_babysitter = babysitter_pipe[0];
        babysitter_pipe[0] = -1;

        sitter->error_pipe_from_child = child_err_report_pipe[READ_END];
        child_err_report_pipe[READ_END] = -1;

        sitter->sitter_pid = pid;

        if (sitter_p != NULL)
            *sitter_p = sitter;
        else
            _dbus_babysitter_unref (sitter);

        dbus_free_string_array (env);

        _DBUS_ASSERT_ERROR_IS_CLEAR (error);

        return TRUE;
    }

cleanup_and_fail:

    _DBUS_ASSERT_ERROR_IS_SET (error);

    close_and_invalidate (&child_err_report_pipe[READ_END]);
    close_and_invalidate (&child_err_report_pipe[WRITE_END]);
    close_and_invalidate (&babysitter_pipe[0]);
    close_and_invalidate (&babysitter_pipe[1]);

    if (sitter != NULL)
        _dbus_babysitter_unref (sitter);

    return FALSE;
}
Пример #4
0
EXPORT_C
#endif
dbus_bool_t
_dbus_spawn_async_with_babysitter (DBusBabysitter          **sitter_p,
                                   char                    **argv,
                                   DBusSpawnChildSetupFunc   child_setup,
                                   void                     *user_data,
                                   DBusError                *error)
{

#ifndef __SYMBIAN32__
  DBusBabysitter *sitter;
  int child_err_report_pipe[2] = { -1, -1 };
  int babysitter_pipe[2] = { -1, -1 };
  pid_t pid;
  
  #ifndef __SYMBIAN32__
  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  *sitter_p = NULL;
  sitter = NULL;

  sitter = _dbus_babysitter_new ();
  if (sitter == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      return FALSE;
    }

  sitter->executable = _dbus_strdup (argv[0]);
  if (sitter->executable == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
  
  if (!make_pipe (child_err_report_pipe, error))
    goto cleanup_and_fail;

  _dbus_fd_set_close_on_exec (child_err_report_pipe[READ_END]);
  _dbus_fd_set_close_on_exec (child_err_report_pipe[WRITE_END]);

  if (!_dbus_full_duplex_pipe (&babysitter_pipe[0], &babysitter_pipe[1], TRUE, error))
    goto cleanup_and_fail;

  _dbus_fd_set_close_on_exec (babysitter_pipe[0]);
  _dbus_fd_set_close_on_exec (babysitter_pipe[1]);

  /* Setting up the babysitter is only useful in the parent,
   * but we don't want to run out of memory and fail
   * after we've already forked, since then we'd leak
   * child processes everywhere.
   */
  sitter->error_watch = _dbus_watch_new (child_err_report_pipe[READ_END],
                                         DBUS_WATCH_READABLE,
                                         TRUE, handle_watch, sitter, NULL);
  if (sitter->error_watch == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
        
  if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->error_watch))
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
      
  sitter->sitter_watch = _dbus_watch_new (babysitter_pipe[0],
                                          DBUS_WATCH_READABLE,
                                          TRUE, handle_watch, sitter, NULL);
  if (sitter->sitter_watch == NULL)
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }
      
  if (!_dbus_watch_list_add_watch (sitter->watches,  sitter->sitter_watch))
    {
      dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
      goto cleanup_and_fail;
    }

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  
  pid = fork ();
  
  if (pid < 0)
    {
      dbus_set_error (error,
		      DBUS_ERROR_SPAWN_FORK_FAILED,
		      "Failed to fork (%s)",
		      _dbus_strerror (errno));
      goto cleanup_and_fail;
    }
  else if (pid == 0)
    {
      /* Immediate child, this is the babysitter process. */
      int grandchild_pid;
      
      /* Be sure we crash if the parent exits
       * and we write to the err_report_pipe
       */
#ifndef __SYMBIAN32__       
      signal (SIGPIPE, SIG_DFL);
#endif      

      /* Close the parent's end of the pipes. */
      close_and_invalidate (&child_err_report_pipe[READ_END]);
      close_and_invalidate (&babysitter_pipe[0]);
      
      /* Create the child that will exec () */
      grandchild_pid = fork ();
      
      if (grandchild_pid < 0)
	{
	  write_err_and_exit (babysitter_pipe[1],
			      CHILD_FORK_FAILED);
          _dbus_assert_not_reached ("Got to code after write_err_and_exit()");
	}
      else if (grandchild_pid == 0)
	{
	  do_exec (child_err_report_pipe[WRITE_END],
		   argv,
		   child_setup, user_data);
          _dbus_assert_not_reached ("Got to code after exec() - should have exited on error");
	}
      else
	{
          babysit (grandchild_pid, babysitter_pipe[1]);
          _dbus_assert_not_reached ("Got to code after babysit()");
	}
    }
  else
    {      
      /* Close the uncared-about ends of the pipes */
      close_and_invalidate (&child_err_report_pipe[WRITE_END]);
      close_and_invalidate (&babysitter_pipe[1]);

      sitter->socket_to_babysitter = babysitter_pipe[0];
      babysitter_pipe[0] = -1;
      
      sitter->error_pipe_from_child = child_err_report_pipe[READ_END];
      child_err_report_pipe[READ_END] = -1;

      sitter->sitter_pid = pid;

      if (sitter_p != NULL)
        *sitter_p = sitter;
      else
        _dbus_babysitter_unref (sitter);

      _DBUS_ASSERT_ERROR_IS_CLEAR (error);
      
      return TRUE;
    }

 cleanup_and_fail:

  _DBUS_ASSERT_ERROR_IS_SET (error);
  
  close_and_invalidate (&child_err_report_pipe[READ_END]);
  close_and_invalidate (&child_err_report_pipe[WRITE_END]);
  close_and_invalidate (&babysitter_pipe[0]);
  close_and_invalidate (&babysitter_pipe[1]);

  if (sitter != NULL)
    _dbus_babysitter_unref (sitter);
  #endif
  return FALSE;
  
  
#else


/*
FILE* ChildProcessStream;
 ChildProcessStream =popen(argv[0], "r");
	if (ChildProcessStream == NULL)
	{
	 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
                      "Failed to execute service process");
     	 return FALSE;
      
	}
*/
 //static pid_t Childpid; //have to make it static for thread fuction to access it
 pid_t childPid;
 int retVal; 
 
 //pthread_t thread;

 retVal = posix_spawn(&childPid, argv[0], NULL,NULL, NULL, NULL);
  	if (retVal!=0)
	{
	 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
                      "Failed to execute service process");
     	 return FALSE;
      
	}

/*
 pthread_create(&thread, NULL, (void*)&thread_fun, &Childpid);
//(void) waitpid(Childpid, NULL, 0);
//printf("\r\n*** Child process finished ***\r\n");

*/

if(!retVal)
	return TRUE;
else
	return FALSE;

#endif  
}