~jamesodhunt/upstart/async-spawn.20140310

/* upstart
 *
 * test_util_common.c - common test utilities
 *
 * Copyright © 2012-2013 Canonical Ltd.
 * Author: James Hunt <james.hunt@canonical.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2, as
 * published by the Free Software Foundation.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

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

#include <nih/test.h>
#include <nih/file.h>
#include <nih/string.h>
#include <nih/signal.h>
#include <nih/logging.h>
#include <nih-dbus/test_dbus.h>

#include <dbus/dbus.h>

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <regex.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>

#include <nih-dbus/dbus_error.h>
#include <nih-dbus/dbus_connection.h>
#include <nih-dbus/dbus_proxy.h>
#include <nih-dbus/errors.h>  

#include "dbus/upstart.h"

#include "test_util_common.h"

#ifndef UPSTART_BINARY
#error unable to find init binary as UPSTART_BINARY not defined
#endif /* UPSTART_BINARY */

#ifndef INITCTL_BINARY
#error unable to find initctl binary as INITCTL_BINARY not defined
#endif /* INITCTL_BINARY */

static void selfpipe_write (int n);
static void selfpipe_setup (void);

/**
 * wait_for_upstart:
 *
 * @user: TRUE if waiting for a Session Init (which uses a private bus
 * rather than the session bus), else FALSE.
 *
 * Wait for Upstart to appear on D-Bus denoting its completion of
 * initialisation. Wait time is somewhat arbitrary (but more
 * than adequate!).
 **/
void
wait_for_upstart (int user)
{
	nih_local NihDBusProxy *upstart = NULL;
	DBusConnection         *connection;
	char                   *address;
	NihError               *err;
	int                     running = FALSE;

	/* XXX: arbitrary value */
	int                     attempts = 10;

	if (user) {
		TEST_TRUE (set_upstart_session ());
		address = getenv ("UPSTART_SESSION");
	} else {
		address = getenv ("DBUS_SESSION_BUS_ADDRESS");
	}

	TEST_TRUE (address);

	while (attempts) {
		attempts--;
		sleep (1);
		connection = nih_dbus_connect (address, NULL);

		if (! connection) {
			err = nih_error_get ();
			nih_free (err);
			continue;
		}

		upstart = nih_dbus_proxy_new (NULL, connection,
				      	      NULL,
					      DBUS_PATH_UPSTART,
				      	      NULL, NULL);

		if (! upstart) {
			err = nih_error_get ();
			nih_free (err);
			dbus_connection_unref (connection);
		} else {
			running = TRUE;
			break;
		}
	}
	TEST_EQ (running, TRUE);
}

/* TRUE to denote that Upstart is running in user session mode
 * (FALSE to denote it's using the users D-Bus session bus).
 */
int test_user_mode = FALSE;

/**
 * set_upstart_session:
 *
 * Attempt to "enter" an Upstart session by setting UPSTART_SESSION to
 * the value of the currently running session.
 *
 * It is only legitimate to call this function if you have previously
 * started a Session Init process.
 *
 * Limitations: Assumes that at most 1 session is running.
 *
 * Returns: TRUE if it was possible to enter the currently running
 * Upstart session, else FALSE.
 **/
int
set_upstart_session (void)
{
	char                     *value;
	nih_local char           *cmd = NULL;
	nih_local char          **output = NULL;
	size_t                    lines = 0;
	int                       got = FALSE;
	int                       i;

	/* XXX: arbitrary value */
	int                       loops = 5;

	/* list-sessions relies on this */
	if (! getenv ("XDG_RUNTIME_DIR"))
		return FALSE;

	cmd = nih_sprintf (NULL, "%s list-sessions 2>&1", INITCTL_BINARY);
	TEST_NE_P (cmd, NULL);

	/* We expect the list-sessions command to return a valid session
	 * within a reasonable period of time.
	 */
	for (i = 0; i < loops; i++) {
		sleep (1);

		RUN_COMMAND (NULL, cmd, &output, &lines);
		if (lines != 1)
			continue;

		/* No pid in output */
		if (! isdigit(output[0][0]))
			continue;

		/* look for separator between pid and value of
		 * UPSTART_SESSION.
		 */
		value = strstr (output[0], " ");
		if (! value)
			continue;

		/* jump over space */
		value  += 1;
		if (! value)
			continue;

		/* No socket address */
		if (strstr (value, "unix:abstract") == value) {
			got = TRUE;
			break;
		}
	}

	if (got != TRUE)
		return FALSE;

	assert0 (setenv ("UPSTART_SESSION", value, 1));

	return TRUE;
}

/**
 * selfpipe:
 *
 * Used to allow a timed process wait.
 **/
static int selfpipe[2] = { -1, -1 };

static void
selfpipe_write (int n)
{
    assert (selfpipe[1] != -1);

    TEST_EQ (write (selfpipe[1], "", 1), 1);
}

/**
 * selfpipe_setup:
 *
 * Arrange for SIGCHLD to write to selfpipe such that we can select(2)
 * on child process status changes.
 **/
static void
selfpipe_setup (void)
{
    static struct sigaction  act;
    int                      read_flags;
    int                      write_flags;

    assert (selfpipe[0] == -1);

    assert (! pipe (selfpipe));

    /* Set non-blocking */
    read_flags = fcntl (selfpipe[0], F_GETFL);
    write_flags = fcntl (selfpipe[1], F_GETFL);

    read_flags |= O_NONBLOCK;
    write_flags |= O_NONBLOCK;

    assert (fcntl (selfpipe[0], F_SETFL, read_flags) == 0);
    assert (fcntl (selfpipe[1], F_SETFL, write_flags) == 0);

    /* Don't leak */
    assert (fcntl (selfpipe[0], F_SETFD, FD_CLOEXEC) == 0);
    assert (fcntl (selfpipe[1], F_SETFD, FD_CLOEXEC) == 0);

    memset (&act, 0, sizeof (act));

    /* register SIGCHLD handler which will cause pipe write when child
     * changes state.
     */
    act.sa_handler = selfpipe_write;

    sigaction (SIGCHLD, &act, NULL);
}

/**
 * timed_waitpid:
 *
 * @pid: pid to wait for,
 * @timeout: seconds to wait for @pid to change state.
 *
 * Simplified waitpid(2) with timeout using a pipe to allow select(2)
 * with timeout to be used to wait for process state change.
 **/
pid_t
timed_waitpid (pid_t pid, time_t timeout)
{
    static char     buffer[1];
    fd_set          read_fds;
    struct timeval  tv;
    int             status;
    int             nfds;
    int             ret;
    pid_t           ret2;

    assert (pid);
    assert (timeout);

    if (selfpipe[0] == -1)
	    selfpipe_setup ();

    FD_ZERO (&read_fds);
    FD_SET (selfpipe[0], &read_fds);

    nfds = 1 + selfpipe[0];

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

    /* wait for some activity */
    ret = select (nfds, &read_fds, NULL, NULL, &tv);

    if (! ret)
	    /* timed out */
	    return 0;

    /* discard any data written to pipe */
    while (read (selfpipe[0], buffer, sizeof (buffer)) > 0)
	    ;

    while (TRUE) {
	    /* wait for status change or error */
	    ret2 = waitpid (pid, &status, WNOHANG);

	    if (ret2 < 0)
		    return -1;

	    if (! ret2)
		    /* give child a chance to change state */
		    sleep (1);

	    if (ret2) {
		    if (WIFEXITED (status))
			    return ret2;

		    /* unexpected status change */
		    return -1;
	    }
    }
}


/**
 * get_initctl():
 *
 * Determine a suitable initctl command-line for testing purposes.
 *
 * Returns: Static string representing full path to initctl binary with
 * default option to allow communication with an Upstart started using
 * START_UPSTART().
 **/
char *
get_initctl (void)
{
	static char path[PATH_MAX + 1024] = { 0 };
	int         ret;

	ret = sprintf (path, "%s %s",
			INITCTL_BINARY,
			test_user_mode
			? "--user"
			: "--session");

	assert (ret > 0);

	return path;
}

/*
 * _start_upstart:
 *
 * @pid: PID of running instance,
 * @user: TRUE if upstart will run in User Session mode (FALSE to
 *  use the users D-Bus session bus),
 * @args: optional list of arguments to specify.
 *
 * Start an instance of Upstart.
 *
 * If the instance fails to start, abort(3) is called.
 **/
void
_start_upstart (pid_t *pid, int user, char * const *args)
{
	nih_local char  **argv = NULL;
	sigset_t          child_set, orig_set;

	assert (pid);

	argv = NIH_MUST (nih_str_array_new (NULL));

	NIH_MUST (nih_str_array_add (&argv, NULL, NULL,
				UPSTART_BINARY));

	if (args)
		NIH_MUST (nih_str_array_append (&argv, NULL, NULL, args));

	sigfillset (&child_set);
	sigprocmask (SIG_BLOCK, &child_set, &orig_set);

	TEST_NE (*pid = fork (), -1);

	if (! *pid) {
		int fd;
		nih_signal_reset ();
		sigprocmask (SIG_SETMASK, &orig_set, NULL);

		if (! getenv ("UPSTART_TEST_VERBOSE")) {
			fd = open ("/dev/null", O_RDWR);
			assert (fd >= 0);
			assert (dup2 (fd, STDIN_FILENO) != -1);
			assert (dup2 (fd, STDOUT_FILENO) != -1);
			assert (dup2 (fd, STDERR_FILENO) != -1);
		}

		assert (execv (argv[0], argv) != -1);
	}

	sigprocmask (SIG_SETMASK, &orig_set, NULL);
	wait_for_upstart (user);
}

/**
 * start_upstart_common:
 *
 * @pid: PID of running instance,
 * @user: TRUE if upstart should run in User Session mode (FALSE to
 * use the users D-Bus session bus),
 * @confdir: full path to configuration directory,
 * @logdir: full path to log directory,
 * @extra: optional extra arguments.
 *
 * Wrapper round _start_upstart() which specifies common options.
 **/
void
start_upstart_common (pid_t *pid, int user, const char *confdir,
		      const char *logdir, char * const *extra)
{
	nih_local char  **args = NULL;

	assert (pid);

	args = NIH_MUST (nih_str_array_new (NULL));

	if (user) {
		NIH_MUST (nih_str_array_add (&args, NULL, NULL,
					"--user"));
		test_user_mode = TRUE;
	} else {
		TEST_TRUE (getenv ("DBUS_SESSION_BUS_ADDRESS"));
		NIH_MUST (nih_str_array_add (&args, NULL, NULL,
					"--session"));
	}

	NIH_MUST (nih_str_array_add (&args, NULL, NULL,
				"--no-startup-event"));

	NIH_MUST (nih_str_array_add (&args, NULL, NULL,
				"--no-sessions"));

	NIH_MUST (nih_str_array_add (&args, NULL, NULL,
				"--no-inherit-env"));

	if (confdir) {
		NIH_MUST (nih_str_array_add (&args, NULL, NULL,
					"--confdir"));
		NIH_MUST (nih_str_array_add (&args, NULL, NULL,
					confdir));
	}

	if (logdir) {
		NIH_MUST (nih_str_array_add (&args, NULL, NULL,
					"--logdir"));
		NIH_MUST (nih_str_array_add (&args, NULL, NULL,
					logdir));
	}

	if (extra)
		NIH_MUST (nih_str_array_append (&args, NULL, NULL, extra));

	_start_upstart (pid, user, args);
}

/**
 * start_upstart:
 *
 * @pid: PID of running instance.
 *
 * Wrapper round _start_upstart() which just runs an instance with no
 * options.
 **/
void
start_upstart (pid_t *pid)
{
	start_upstart_common (pid, FALSE, NULL, NULL, NULL);
}

/**
 * job_to_pid:
 *
 * @job: job name.
 *
 * Determine pid of running job.
 *
 * WARNING: it is the callers responsibility to ensure that
 * @job is still running when this function is called!!
 *
 * Returns: pid of job, or -1 if not found.
 **/
pid_t
job_to_pid (const char *job)
{
	pid_t            pid;
	regex_t          regex;
	regmatch_t       regmatch[2];
	int              ret;
	nih_local char  *cmd = NULL;
	nih_local char  *pattern = NULL;
	size_t           lines;
	char           **status;
	nih_local char  *str_pid = NULL;

	assert (job);

	pattern = NIH_MUST (nih_sprintf
			(NULL, "^\\b%s\\b .*, process ([0-9]+)", job));

	cmd = NIH_MUST (nih_sprintf (NULL, "%s status %s 2>&1",
			get_initctl (), job));
	RUN_COMMAND (NULL, cmd, &status, &lines);
	TEST_EQ (lines, 1);

	ret = regcomp (&regex, pattern, REG_EXTENDED);
	assert0 (ret);

	ret = regexec (&regex, status[0], 2, regmatch, 0);
	if (ret == REG_NOMATCH) {
		ret = -1;
		goto out;
	}
	assert0 (ret);

	if (regmatch[1].rm_so == -1 || regmatch[1].rm_eo == -1) {
		ret = -1;
		goto out;
	}

	/* extract the pid */
	NIH_MUST (nih_strncat (&str_pid, NULL,
			&status[0][regmatch[1].rm_so],
			regmatch[1].rm_eo - regmatch[1].rm_so));

	nih_free (status);

	pid = (pid_t)atol (str_pid);

	/* check it's running */
	ret = kill (pid, 0);
	if (! ret)
		ret = pid;

out:
	regfree (&regex);
	return ret;
}

const char *
get_upstart_binary (void)
{
	return UPSTART_BINARY;
}

const char *
get_initctl_binary (void)
{
	return INITCTL_BINARY;
}

/**
 * string_check:
 *
 * @a: first string,
 * @b: second string.
 *
 * Compare @a and @b either or both of which may be NULL.
 *
 * Returns 0 if strings are identical or both NULL, else 1.
 **/
int
string_check (const char *a, const char *b)
{
	if (!a && !b)
		return 0;

	if (!a || !b)
		return 1;

	if (strcmp (a, b))
		return 1;

	return 0;
}

/**
 * strcmp_compar:
 *
 * @a: first string,
 * @b: second string.
 *
 * String comparison function suitable for passing to qsort(3).
 * See the qsort(3) man page for further details.
 **/
int
strcmp_compar (const void *a, const void *b)
{
	return strcmp(*(char * const *)a, *(char * const *)b);
}

/**
 * get_session_file:
 *
 * @xdg_runtime_dir: Directory to treat as XDG_RUNTIME_DIR,
 * @pid: pid of running Session Init instance.
 *
 * Determine full path to a Session Inits session file.
 *
 * Note: No check on the existence of the session file is performed.
 *
 * Returns: Newly-allocated string representing full path to Session
 *          Inits session file.
 **/
char *
get_session_file (const char *xdg_runtime_dir, pid_t pid)
{
	char *session_file;
	
	nih_assert (xdg_runtime_dir);
	nih_assert (pid);

	session_file = nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
			xdg_runtime_dir, (int)pid);

	nih_assert (session_file);

	return session_file;
}