/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/* tests/unlockiter.c - test program for unlocked iteration */
/*
 * Copyright (C) 2014 by the Massachusetts Institute of Technology.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Test unlocked KDB iteration.
 */

#include <sys/types.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <errno.h>
#include <krb5.h>
#include <kadm5/admin.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>             /* Some platforms need memset() for FD_ZERO */
#include <unistd.h>

struct cb_arg {
    int inpipe;
    int outpipe;
    int timeout;
    int done;
};

/* Helper function for cb(): read a sync byte (with possible timeout), then
 * write a sync byte. */
static int
syncpair_rw(const char *name, struct cb_arg *arg, char *cp, int timeout)
{
    struct timeval tv;
    fd_set rset;
    int nfds;

    FD_ZERO(&rset);
    FD_SET(arg->inpipe, &rset);
    tv.tv_sec = timeout;
    tv.tv_usec = 0;

    printf("cb: waiting for %s sync pair\n", name);
    nfds = select(arg->inpipe + 1, &rset,
                  NULL, NULL, (timeout == 0) ? NULL : &tv);
    if (nfds < 0)
        return -1;
    if (nfds == 0) {
        errno = ETIMEDOUT;
        return -1;
    }
    if (read(arg->inpipe, cp, 1) < 0)
        return -1;
    printf("cb: writing %s sync pair\n", name);
    if (write(arg->outpipe, cp, 1) < 0)
        return -1;
    return 0;
}

/* On the first iteration only, receive and send sync bytes to the locking
 * child to drive its locking activities. */
static krb5_error_code
cb(void *argin, krb5_db_entry *ent)
{
    struct cb_arg *arg = argin;
    char c = '\0';

    if (arg->done)
        return 0;

    if (syncpair_rw("first", arg, &c, 0) < 0) {
        com_err("cb", errno, "first sync pair");
        return errno;
    }
    if (syncpair_rw("second", arg, &c, arg->timeout) < 0) {
        com_err("cb", errno, "second sync pair");
        return errno;
    }
    printf("cb: waiting for final sync byte\n");
    if (read(arg->inpipe, &c, 1) < 0) {
        com_err("cb", errno, "final sync byte");
        return errno;
    }
    arg->done = 1;
    return 0;
}

/* Parent process: iterate over the KDB, using a callback that synchronizes
 * with the locking child. */
static int
iterator(struct cb_arg *cb_arg, char **db_args, pid_t child)
{
    krb5_error_code retval;
    krb5_context ctx;

    retval = krb5_init_context_profile(NULL, KRB5_INIT_CONTEXT_KDC, &ctx);
    if (retval)
        goto cleanup;

    retval = krb5_db_open(ctx, db_args,
                          KRB5_KDB_OPEN_RW | KRB5_KDB_SRV_TYPE_ADMIN);
    if (retval)
        goto cleanup;

    retval = krb5_db_iterate(ctx, NULL, cb, cb_arg, 0);
    if (retval)
        goto cleanup;

    retval = krb5_db_fini(ctx);

cleanup:
    krb5_free_context(ctx);
    if (retval) {
        com_err("iterator", retval, "");
        kill(child, SIGTERM);
        exit(1);
    }
    return retval;
}

/* Helper function for locker(): write, then receive a sync byte. */
static int
syncpair_wr(const char *name, int inpipe, int outpipe, unsigned char *cp)
{
    printf("locker: writing %s sync pair\n", name);
    if (write(outpipe, cp, 1) < 0)
        return -1;
    printf("locker: waiting for %s sync pair\n", name);
    if (read(inpipe, cp, 1) < 0)
        return -1;
    return 0;
}

/* Child process: acquire and release a write lock on the KDB, synchronized
 * with parent. */
static int
locker(int inpipe, int outpipe, char **db_args)
{
    krb5_error_code retval;
    unsigned char c = '\0';
    krb5_context ctx;

    retval = krb5_init_context_profile(NULL, KRB5_INIT_CONTEXT_KDC, &ctx);
    if (retval)
        goto cleanup;

    retval = krb5_db_open(ctx, db_args,
                          KRB5_KDB_OPEN_RW | KRB5_KDB_SRV_TYPE_ADMIN);
    if (retval)
        goto cleanup;

    if (syncpair_wr("first", inpipe, outpipe, &c) < 0) {
        retval = errno;
        goto cleanup;
    }
    printf("locker: acquiring lock...\n");
    retval = krb5_db_lock(ctx, KRB5_DB_LOCKMODE_EXCLUSIVE);
    if (retval)
        goto cleanup;
    printf("locker: acquired lock\n");
    if (syncpair_wr("second", inpipe, outpipe, &c) < 0) {
        retval = errno;
        goto cleanup;
    }
    krb5_db_unlock(ctx);
    printf("locker: released lock\n");
    printf("locker: writing final sync byte\n");
    if (write(outpipe, &c, 1) < 0) {
        retval = errno;
        goto cleanup;
    }
    retval = krb5_db_fini(ctx);
cleanup:
    if (retval)
        com_err("locker", retval, "");

    krb5_free_context(ctx);
    exit(retval != 0);
}

static void
usage(const char *prog)
{
    fprintf(stderr, "usage: %s [-lu] [-t timeout]\n", prog);
    exit(1);
}

int
main(int argc, char *argv[])
{
    struct cb_arg cb_arg;
    pid_t child;
    char *db_args[2] = { NULL, NULL };
    int c;
    int cstatus;
    int pipe_to_locker[2], pipe_to_iterator[2];

    cb_arg.timeout = 1;
    cb_arg.done = 0;
    while ((c = getopt(argc, argv, "lt:u")) != -1) {
        switch (c) {
        case 'l':
            db_args[0] = "lockiter";
            break;
        case 't':
            cb_arg.timeout = atoi(optarg);
            break;
        case 'u':
            db_args[0] = "unlockiter";
            break;
        default:
            usage(argv[0]);
        }
    }
    if (pipe(pipe_to_locker) < 0) {
        com_err(argv[0], errno, "pipe(p_il)");
        exit(1);
    }
    if (pipe(pipe_to_iterator) < 0) {
        com_err(argv[0], errno, "pipe(p_li)");
        exit(1);
    }
    cb_arg.inpipe = pipe_to_iterator[0];
    cb_arg.outpipe = pipe_to_locker[1];
    child = fork();
    switch (child) {
    case -1:
        com_err(argv[0], errno, "fork");
        exit(1);
        break;
    case 0:
        locker(pipe_to_locker[0], pipe_to_iterator[1], db_args);
        break;
    default:
        if (iterator(&cb_arg, db_args, child))
            exit(1);
        if (wait(&cstatus) < 0) {
            com_err(argv[0], errno, "wait");
            exit(1);
        }
        if (WIFSIGNALED(cstatus))
            exit(1);
        if (WIFEXITED(cstatus) && WEXITSTATUS(cstatus) != 0) {
            exit(1);
        }
    }
    exit(0);
}