/**

 * Seccomp Library utility code for tests

 *

 * Copyright (c) 2012 Red Hat <eparis@redhat.com>

 * Author: Eric Paris <eparis@redhat.com>

 */

/*

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

 * under the terms of version 2.1 of the GNU Lesser General Public License as

 * published by the Free Software Foundation.

 *

 * 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, see <http://www.gnu.org/licenses>.

 */

#include <errno.h>

#include <fcntl.h>

#include <getopt.h>

#include <signal.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <seccomp.h>

#include "util.h"

/**

 * SIGSYS signal handler

 * @param nr the signal number

 * @param info siginfo_t pointer

 * @param void_context handler context

 *

 * Simple signal handler for SIGSYS which exits with error code 161.

 *

 */

static void _trap_handler(int signal, siginfo_t *info, void *ctx)

{

	_exit(161);

}

/**

 * Parse the arguments passed to main

 * @param argc the argument count

 * @param argv the argument pointer

 * @param opts the options structure

 *

 * This function parses the arguments passed to the test from the command line.

 * Returns zero on success and negative values on failure.

 *

 */

int util_getopt(int argc, char *argv[], struct util_options *opts)

{

	int rc = 0;

	if (opts == NULL)

		return -EFAULT;

	memset(opts, 0, sizeof(*opts));

	while (1) {

		int c, option_index = 0;

		const struct option long_options[] = {

			{"bpf", no_argument, &(opts->bpf_flg), 1},

			{"pfc", no_argument, &(opts->bpf_flg), 0},

			{0, 0, 0, 0},

		};

		c = getopt_long(argc, argv, "bp",

				long_options, &option_index);

		if (c == -1)

			break;

		switch (c) {

		case 0:

			break;

		case 'b':

			opts->bpf_flg = 1;

			break;

		case 'p':

			opts->bpf_flg = 0;

			break;

		default:

			rc = -EINVAL;

			break;

		}

	}

	if (rc == -EINVAL || optind < argc) {

		fprintf(stderr, "usage %s: [--bpf,-b] [--pfc,-p]\n", argv[0]);

		rc = -EINVAL;

	}

	return rc;

}

/**

 * Output the filter in either BPF or PFC

 * @param opts the options structure

 * @param ctx the filter context

 *

 * This function outputs the seccomp filter to stdout in either BPF or PFC

 * format depending on the test paramaeters supplied by @opts.

 *

 */

int util_filter_output(const struct util_options *opts,

		       const scmp_filter_ctx ctx)

{

	int rc;

	if (opts == NULL)

		return -EFAULT;

	if (opts->bpf_flg)

		rc = seccomp_export_bpf(ctx, STDOUT_FILENO);

	else

		rc = seccomp_export_pfc(ctx, STDOUT_FILENO);

	return rc;

}

/**

 * Install a TRAP action signal handler

 *

 * This function installs the TRAP action signal handler and is based on

 * examples from Will Drewry and Kees Cook.  Returns zero on success, negative

 * values on failure.

 *

 */

int util_trap_install(void)

{

	struct sigaction signal_handler;

	sigset_t signal_mask;

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

	sigemptyset(&signal_mask);

	sigaddset(&signal_mask, SIGSYS);

	signal_handler.sa_sigaction = &_trap_handler;

	signal_handler.sa_flags = SA_SIGINFO;

	if (sigaction(SIGSYS, &signal_handler, NULL) < 0)

		return -errno;

	if (sigprocmask(SIG_UNBLOCK, &signal_mask, NULL))

		return -errno;

	return 0;

}

/**

 * Parse a filter action string into an action value

 * @param action the action string

 *

 * Parse a seccomp action string into the associated integer value.  Returns

 * the correct value on success, -1 on failure.

 *

 */

int util_action_parse(const char *action)

{

	if (action == NULL)

		return -1;

	if (strcasecmp(action, "KILL") == 0)

		return SCMP_ACT_KILL;

	if (strcasecmp(action, "KILL_PROCESS") == 0)

		return SCMP_ACT_KILL_PROCESS;

	else if (strcasecmp(action, "TRAP") == 0)

		return SCMP_ACT_TRAP;

	else if (strcasecmp(action, "ERRNO") == 0)

		return SCMP_ACT_ERRNO(163);

	else if (strcasecmp(action, "TRACE") == 0)

		return -1; /* not yet supported */

	else if (strcasecmp(action, "ALLOW") == 0)

		return SCMP_ACT_ALLOW;

	else if (strcasecmp(action, "LOG") == 0)

		return SCMP_ACT_LOG;

	return -1;

}

/**

 * Write a string to a file

 * @param path the file path

 *

 * Open the specified file, write a string to the file, and close the file.

 * Return zero on success, negative values on error.

 *

 */

int util_file_write(const char *path)

{

	int fd;

	const char buf[] = "testing";

	ssize_t buf_len = strlen(buf);

	fd = open(path, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);

	if (fd < 0)

		return errno;

	if (write(fd, buf, buf_len) < buf_len) {

		int rc = errno;

		close(fd);

		return rc;

	}

	if (close(fd) < 0)

		return errno;

	return 0;

}