openSUSE Build Service

Overview Repositories Revisions Requests Users Attributes Meta

File waitmax.c of Package check_mk

// +------------------------------------------------------------------+
// |             ____ _               _        __  __ _  __           |
// |            / ___| |__   ___  ___| | __   |  \/  | |/ /           |
// |           | |   | '_ \ / _ \/ __| |/ /   | |\/| | ' /            |
// |           | |___| | | |  __/ (__|   <    | |  | | . \            |
// |            \____|_| |_|\___|\___|_|\_\___|_|  |_|_|\_\           |
// |                                                                  |
// | Copyright Mathias Kettner 2014             mk@mathias-kettner.de |
// +------------------------------------------------------------------+
//
// This file is part of Check_MK.
// The official homepage is at http://mathias-kettner.de/check_mk.
//
// check_mk is free software;  you can redistribute it and/or modify it
// under the  terms of the  GNU General Public License  as published by
// the Free Software Foundation in version 2.  check_mk is  distributed
// in the hope that it will be useful, but WITHOUT ANY WARRANTY;  with-
// out even the implied warranty of  MERCHANTABILITY  or  FITNESS FOR A
// PARTICULAR PURPOSE. See the  GNU General Public License for more de-
// ails.  You should have  received  a copy of the  GNU  General Public
// License along with GNU Make; see the file  COPYING.  If  not,  write
// to the Free Software Foundation, Inc., 51 Franklin St,  Fifth Floor,
// Boston, MA 02110-1301 USA.

#include <errno.h>
#include <getopt.h>
#include <signal.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

static pid_t g_pid = 0;
static int g_timeout = 0;
static int g_signum = SIGTERM;

static void out(const char *buf) {
    size_t bytes_to_write = strlen(buf);
    while (bytes_to_write > 0) {
        ssize_t written = write(STDERR_FILENO, buf, bytes_to_write);
        if (written == -1) {
            if (errno == EINTR) continue;
            return;
        }
        buf += written;
        bytes_to_write -= written;
    }
}

static void exit_with(const char *message, int err, int status) {
    out(message);
    if (err != 0) {
        out(": ");
        out(strerror(errno));
    }
    out("\n");
    exit(status);
}

static void version() {
    exit_with(
        "waitmax version 1.1\n"
        "Copyright Mathias Kettner 2008\n"
        "This is free software; see the source for copying conditions.  "
        "There is NO\n"
        "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR "
        "PURPOSE.",
        0, 0);
}

static void usage(int status) {
    exit_with(
        "Usage: waitmax [-s SIGNUM] MAXTIME PROGRAM [ARGS...]\n"
        "\n"
        "Execute PROGRAM as a subprocess. If PROGRAM does not exit before "
        "MAXTIME\n"
        "seconds, it will be killed with SIGTERM or an alternative signal.\n"
        "\n"
        "   -s, --signal SIGNUM   kill with SIGNUM on timeout\n"
        "   -h, --help            this help\n"
        "   -V, --version         show version an exit\n",
        0, status);
}

static void kill_group(pid_t pid, int signum) {
    /* The child might have become a process group leader itself, so send the
       signal directly to it. */
    kill(pid, signum);

/* Guard against harakiri... */
    signal(signum, SIG_IGN);

/* Send the signal to all processes in our fresh process group. */
    kill(0, signum);
}

static void signalhandler(int signum) {
    if (signum == SIGALRM) {
        /* The child took too long, so remember that we timed out and send the
           configured signal instead of SIGALRM. */
        g_timeout = 1;
        signum = g_signum;
    }

/* Are we the child process or has the child not been execvp'd yet? */
    if (g_pid == 0) exit(signum + 128);

/* Send the configure signal to our process group. */
    kill_group(g_pid, signum);

/* Make sure the children actually react on the signal. */
    if (signum != SIGKILL && signum != SIGCONT) kill_group(g_pid, SIGCONT);
}

static void setup_signal_handlers() {
    struct sigaction sa;
    sigemptyset(&sa.sa_mask);
    sa.sa_handler = signalhandler;
    sa.sa_flags = SA_RESTART; /* just to be sure... */
    sigaction(g_signum, &sa, NULL);
    sigaction(SIGALRM, &sa, NULL);
    sigaction(SIGHUP, &sa, NULL);
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGQUIT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);

/* Guard against a background child doing I/O on the tty. */
    sa.sa_handler = SIG_IGN;
    sigaction(SIGTTIN, &sa, NULL);
    sigaction(SIGTTOU, &sa, NULL);

/* Make sure that waitpid won't fail. */
    sa.sa_handler = SIG_DFL;
    sigaction(SIGCHLD, &sa, NULL);
}

static void unblock_signal(int signum) {
    sigset_t signals_to_unblock;
    sigemptyset(&signals_to_unblock);
    sigaddset(&signals_to_unblock, signum);
    if (sigprocmask(SIG_UNBLOCK, &signals_to_unblock, NULL) == -1)
        exit_with("sigprocmask failed", errno, 1);
}

static struct option long_options[] = {{"version", no_argument, 0, 'V'},
                                       {"help", no_argument, 0, 'h'},
                                       {"signal", required_argument, 0, 's'},
                                       {0, 0, 0, 0}};

int main(int argc, char **argv) {
    /* Note: setenv calls malloc, and 'diet' warns about that. */
    if (getenv("POSIXLY_CORRECT") == NULL) putenv("POSIXLY_CORRECT=true");
    int ret;
    while ((ret = getopt_long(argc, argv, "Vhs:", long_options, NULL)) != -1) {
        switch (ret) {
            case 'V':
                version();
                break;

case 'h':
                usage(0);
                break;

case 's':
                g_signum = atoi(optarg);
                if (g_signum < 1 || g_signum > 32)
                    exit_with("Signalnumber must be between 1 and 32.", 0, 1);
                break;

default:
                usage(1);
                break;
        }
    }

if (optind + 1 >= argc) usage(1);

int maxtime = atoi(argv[optind]);
    if (maxtime <= 0) usage(1);

/* Create a new process group with ourselves as the process group
       leader. This way we can send a signal to all subprocesses later (unless
       some non-direct descendant creates its own process group). Doing this in
       the parent process already simplifies things, because we don't have to
       worry about foreground/background groups then. */
    setpgid(0, 0);

/* Setting up signal handlers before forking avoids race conditions with the
       child. */
    setup_signal_handlers();

g_pid = fork();
    if (g_pid == -1) exit_with("fork() failed", errno, 1);

if (g_pid == 0) {
        /* Restore tty behavior in the child. */
        struct sigaction sa;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = SA_RESTART; /* just to be sure... */
        sa.sa_handler = SIG_DFL;
        sigaction(SIGTTIN, &sa, NULL);
        sigaction(SIGTTOU, &sa, NULL);

execvp(argv[optind + 1], argv + optind + 1);
        exit_with(argv[optind + 1], errno, 253);
    }

/* Make sure SIGALRM is not blocked (e.g. by parent). */
    unblock_signal(SIGALRM);
    alarm(maxtime);

int status;
    while (waitpid(g_pid, &status, 0) == -1) {
        if (errno != EINTR) exit_with("waitpid() failed", errno, 1);
    }

if (WIFEXITED(status)) return WEXITSTATUS(status);
    if (WIFSIGNALED(status)) return g_timeout ? 255 : 128 + WTERMSIG(status);
    exit_with("Program did neither exit nor was signalled.", 0, 254);
    return 0; /* Make GCC happy. */
}

Places

File waitmax.c of Package check_mk

Places