/*      $OpenBSD: test-close.c,v 1.1 2020/06/29 18:25:37 anton Exp $    */

/*
 * Copyright (c) 2019 Anton Lindqvist <anton@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <err.h>
#include <pthread.h>
#include <signal.h>
#include <unistd.h>

#include "pipe.h"

struct context {
        volatile sig_atomic_t *c_alive;
        int c_fd;
};

static void *close_thread(void *);
static void sighandler(int);

static volatile sig_atomic_t alive = 1;

/*
 * Regression during close(2) causing a use-after-free.
 * The main thread repeatedly creates a new pipe which two other threads tries
 * to close. By default, 100 iterations is performed.
 */
int
test_close_race(void)
{
        pthread_t th1, th2;
        struct context ctx1, ctx2;
        int nrounds = 100;
        int pip[2];
        int error;

        if (signal(SIGINT, sighandler) == SIG_ERR)
                err(1, "signal");

        ctx1.c_alive = &alive;
        ctx1.c_fd = 3;
        error = pthread_create(&th1, NULL, close_thread, &ctx1);
        if (error)
                errc(1, error, "pthread_create");
        ctx2.c_alive = &alive;
        ctx2.c_fd = 4;
        error = pthread_create(&th2, NULL, close_thread, &ctx2);
        if (error)
                errc(1, error, "pthread_create");

        while (alive) {
                if (!infinity && nrounds-- == 0)
                        alive = 0;

                if (pipe(pip) == -1)
                        err(1, "pipe");
                if (pip[0] != 3)
                        close(pip[0]);
                if (pip[1] != 4)
                        close(pip[1]);
        }

        error = pthread_join(th1, NULL);
        if (error)
                errc(1, error, "pthread_join");
        error = pthread_join(th2, NULL);
        if (error)
                errc(1, error, "pthread_join");

        return 0;
}

static void *
close_thread(void *arg)
{
        const struct context *ctx = arg;

        while (*ctx->c_alive)
                close(ctx->c_fd);

        return NULL;
}

static void
sighandler(int signo)
{

        alive = 0;
}