/* -*- 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);
}