/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2013 David Hoeppner.  All rights reserved.
 */

/*
 * Queue maximum number of signals and test if we can queue more signals then
 * allowed.
 */

#include <sys/types.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

#define SIGQUEUE_SIGNAL         SIGRTMIN        /* Signal used for testing */

int nreceived = 0;

static void
test_start(const char *test_name, const char *format, ...)
{
        va_list args;

        (void) printf("TEST STARTING %s: ", test_name);

        va_start(args, format);
        (void) vprintf(format, args);
        va_end(args);
        (void) fflush(stdout);
}

static void
test_failed(const char *test_name, const char *format, ...)
{
        va_list args;

        (void) printf("TEST FAILED %s: ", test_name);

        va_start(args, format);
        (void) vprintf(format, args);
        va_end(args);

        (void) exit(-1);
}

static void
test_passed(const char *test_name)
{
        (void) printf("TEST PASS: %s\n", test_name);
        (void) fflush(stdout);
}

/* ARGSUSED */
static void
maximum_test_handler(int signal, siginfo_t *siginfo, void *context)
{
        nreceived++;
}

static void
sigqueue_maximum_test(void)
{
        const char *test_name = __func__;
        struct sigaction action;
        long sigqueue_max, i;
        pid_t pid;
        union sigval value;
        int error;

        test_start(test_name, "queue maximum number of signals\n");

        /*
         * Get the maximum size of the queue.
         */
        sigqueue_max = sysconf(_SC_SIGQUEUE_MAX);
        if (sigqueue_max == -1) {
                test_failed(test_name, "sysconf\n");
        }

        /*
         * Put the signal on hold.
         */
        error = sighold(SIGQUEUE_SIGNAL);
        if (error == -1) {
                test_failed(test_name, "sighold\n");
        }

        pid = getpid();
        value.sival_int = 0;

        action.sa_flags = SA_SIGINFO;
        action.sa_sigaction = maximum_test_handler;

        error = sigemptyset(&action.sa_mask);
        if (error == -1) {
                test_failed(test_name, "sigemptyset\n");
        }

        /*
         * Set signal handler.
         */
        error = sigaction(SIGQUEUE_SIGNAL, &action, 0);
        if (error == -1) {
                test_failed(test_name, "sigaction\n");
        }

        /*
         * Fill the signal queue to the maximum.
         */
        for (i = 0; i < sigqueue_max; i++) {
                error = sigqueue(pid, SIGQUEUE_SIGNAL, value);
                if (error == -1) {
                        test_failed(test_name, "sigqueue\n");
                }
        }

        /*
         * Send a further signal and test if we get the expected
         * error.
         */
        error = sigqueue(pid, SIGQUEUE_SIGNAL, value);
        if (error != -1) {
                test_failed(test_name, "sigqueue\n");
        }

        /*
         * Unblock the signals and check if we received all messages
         * from the signal queue.
         */
        error = sigrelse(SIGQUEUE_SIGNAL);
        if (error == -1) {
                test_failed(test_name, "sigrelse\n");
        }

        if (nreceived != sigqueue_max) {
                test_failed(test_name, "nreceived != sigqueue_max\n");
        }

        test_passed(test_name);
}

static void
run_tests(void)
{
        sigqueue_maximum_test();
}

/* ARGSUSED */
int
main(int argc, char *argv[])
{
        run_tests();

        return (EXIT_SUCCESS);
}