run_kannel_box.c File Reference

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <limits.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>

Go to the source code of this file.

Macros
#define	NUM_EXTRA   ((int) (sizeof(extra_arguments) / sizeof(*extra_arguments)))

Functions
static void	print_usage (FILE *stream)
static void	build_box_arglist (char *boxfile, int argc, char **argv)
static void	write_pidfile (void)
static void	remove_pidfile (void)
static void	rebind_standard_streams (void)
static int	open_max (void)
static void	close_extra_files (void)
static void	signal_transfer (int signum)
static void	signal_transfer_and_die (int signum)
static void	setup_signals (void)
static int	main_loop (char *boxfile)
int	main (int argc, char *argv[])

Variables
static char *	progname
static char **	box_arglist
static int	min_restart_delay = 60
static pid_t	child_box
static char *	pidfile
static int	use_extra_args = 1
static char *	extra_arguments []

Macro Definition Documentation

NUM_EXTRA

#define NUM_EXTRA   ((int) (sizeof(extra_arguments) / sizeof(*extra_arguments)))

Definition at line 84 of file run_kannel_box.c.

Referenced by build_box_arglist().

Function Documentation

build_box_arglist()

static void build_box_arglist ( char *  boxfile, int  argc, char **  argv  )

static

Definition at line 96 of file run_kannel_box.c.

References box_arglist, extra_arguments, free(), malloc(), NUM_EXTRA, progname, and use_extra_args.

Referenced by main().

{
    int i;
    char **argp;

    if (box_arglist) {
        free(box_arglist);
    }

    /* one for the boxfile name itself, one for each extra argument,
     * one for each normal argument, and one for the terminating NULL */
    box_arglist = malloc((1 + NUM_EXTRA + argc + 1) * sizeof(*box_arglist));
    if (!box_arglist) {
        fprintf(stderr, "%s: malloc: %s\n", progname, strerror(errno));
        exit(1);
    }

    /* Have argp walk down box_arglist and set each argument. */
    argp = box_arglist;

    *argp++ = boxfile;
        if (use_extra_args) {
        for (i = 0; i < NUM_EXTRA; i++) {
            *argp++ = extra_arguments[i];
        }
    }
    for (i = 0; i < argc; i++) {
        *argp++ = argv[i];
    }
    *argp++ = (char *)NULL;
}

close_extra_files()

static void close_extra_files ( void  )

static

Definition at line 209 of file run_kannel_box.c.

References open_max().

Referenced by main().

{
    int max = open_max();
    int fd;

    for (fd = 3; fd < max; fd++) {
        close(fd);
    }
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 307 of file run_kannel_box.c.

References build_box_arglist(), close_extra_files(), main_loop(), min_restart_delay, pidfile, print_usage(), progname, rebind_standard_streams(), remove_pidfile(), setup_signals(), use_extra_args, and write_pidfile().

{
    int i;
    char *boxfile = NULL;
    pid_t childpid;

    progname = argv[0];

    if (argc == 1) {
        print_usage(stderr);
        exit(2);
    }

    /* Parse the options meant for the wrapper, and get the name of
     * the box to wrap. */
    for (i = 1; i < argc && !boxfile; i++) {
        if (strcmp(argv[i], "--pidfile") == 0) {
            if (i+1 >= argc) {
                fprintf(stderr, "Missing argument for option %s\n", argv[i]);
                exit(2);
            }
            pidfile = argv[i+1];
            i++;
        } else if (strcmp(argv[i], "--min-delay") == 0) {
            if (i+1 >= argc) {
                fprintf(stderr, "Missing argument for option %s", argv[i]);
                exit(2);
            }
            min_restart_delay = atoi(argv[i+1]);
            i++;
        } else if (strcmp(argv[i], "--no-extra-args") == 0) {
                use_extra_args = 0;
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "Unknown option %s\n", argv[i]);
            exit(2);
        } else {
            boxfile = argv[i];
        }
    }

    /* Check if we have everything */
    if (!boxfile) {
        print_usage(stderr);
        exit(2);
    }

    /* The remaining arguments should be passed to the box */
    build_box_arglist(boxfile, argc - i, argv + i);

    /* Ready to rock.  Begin daemonization. */

    /* Fork a child process and have the parent exit.
         * This makes us run in the background. */
    childpid = fork();
    if (childpid < 0) {
        fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
        exit(1);
    }
    if (childpid != 0) {
        exit(0); /* parent exits immediately */
    }
    
    /* The child continues here.  Now call setsid() to disconnect
     * from our terminal and from the parent's session and process
     * group. */
    if (setsid() < 0) {
        fprintf(stderr, "%s: setsid: %s\n", progname, strerror(errno));
        exit(1);
    }

    /* Change to the root directory, so that we don't keep a
     * file descriptor open on an unknown directory. */
    if (chdir("/") < 0) {
        fprintf(stderr, "%s: chdir to root: %s\n", progname, strerror(errno));
        exit(1);
    }

    atexit(remove_pidfile);
    write_pidfile();

    /* Set the umask to a known value, rather than inheriting
     * an unknown one. */
    umask(077);

    /* Leave file descriptors 0, 1, and 2 pointing to harmless
     * places, and close all other file descriptors. */
    rebind_standard_streams();
    close_extra_files();

    setup_signals();
    return main_loop(boxfile);
}

main_loop()

static int main_loop ( char *  boxfile )

static

Definition at line 262 of file run_kannel_box.c.

References box_arglist, child_box, and min_restart_delay.

Referenced by main().

{
    time_t next_fork = 0;

    /* We can't report any errors here, because we are running
     * as a daemon and we have no logfile of our own.  So we
     * exit with errno as the exit code, to offer a minimal clue. */

    for (;;) {

        /* Make sure we don't fork in an endless loop if something
         * is drastically wrong.  This code limits it to one
         * per minute (or whatever min_restart_delay is set to). */
        time_t this_time = time(NULL);
        if (this_time <= next_fork) {
            sleep(next_fork - this_time);
        }
        next_fork = this_time + min_restart_delay;

        child_box = fork();
        if (child_box < 0) {
            return errno;
        }
        if (child_box == 0) {
            /* child.  exec the box */
            execvp(boxfile, box_arglist);
            exit(127);
        }
        
        while (waitpid(child_box, (int *)NULL, 0) != child_box) {
            if (errno == ECHILD) {
                /* Something went wrong... we don't know what,
                 * but we do know that our child does not
                 * exist.  So restart it. */
                break;
            }
            if (errno == EINTR) {
                continue;
            }
            /* Something weird happened. */
            return errno;
        }
    }
}

open_max()

static int open_max ( void  )

static

Definition at line 193 of file run_kannel_box.c.

Referenced by close_extra_files().

{
#ifdef OPEN_MAX
    return OPEN_MAX;
#else
    int max;

    max = sysconf(_SC_OPEN_MAX);
    if (max <= 0) {
        return 1024;  /* guess */
    }
    return max;
#endif
}

print_usage()

static void print_usage ( FILE *  stream )

static

Definition at line 86 of file run_kannel_box.c.

References progname.

Referenced by main().

{
    fprintf(stream,
        "Usage: %s [--pidfile PIDFILE] [--min-delay SECONDS] BOXPATH [boxoptions...]\n",
        progname);
}

rebind_standard_streams()

static void rebind_standard_streams ( void  )

static

Definition at line 165 of file run_kannel_box.c.

References progname.

Referenced by main().

{
    int devnullfd;
    int devfullfd;

    devnullfd = open("/dev/null", O_RDONLY);
    if (devnullfd < 0) {
        fprintf(stderr, "%s: cannot open /dev/null: %s\n",
            progname, strerror(errno));
        exit(2);
    }
    devfullfd = open("/dev/full", O_WRONLY);
    if (devfullfd < 0) {
        devfullfd = devnullfd;
    }

    /* Alert: The dup on stderr is done last, so that the error message
     * works regardless of which dup fails. */
    if (dup2(devnullfd, 0) < 0 ||
        dup2(devfullfd, 1) < 0 ||
        dup2(devfullfd, 2) < 0) {
        fprintf(stderr, "%s: dup2: %s\n", progname, strerror(errno));
        exit(1);
    }
}

remove_pidfile()

static void remove_pidfile ( void  )

static

Definition at line 155 of file run_kannel_box.c.

References pidfile.

Referenced by main(), and signal_transfer_and_die().

{
    if (!pidfile)
        return;

    unlink(pidfile);
}

setup_signals()

static void setup_signals ( void  )

static

Definition at line 250 of file run_kannel_box.c.

References signal_transfer(), and signal_transfer_and_die().

Referenced by main().

{
    signal(SIGHUP, &signal_transfer);
    signal(SIGINT, &signal_transfer_and_die);
    signal(SIGQUIT, &signal_transfer_and_die);
    signal(SIGTERM, &signal_transfer_and_die);
    signal(SIGUSR1, &signal_transfer);
    signal(SIGUSR2, &signal_transfer);
}

signal_transfer()

static void signal_transfer ( int  signum )

static

Definition at line 221 of file run_kannel_box.c.

References child_box.

Referenced by setup_signals().

{
    if (child_box > 0) {
        kill(child_box, signum);
    }
}

signal_transfer_and_die()

static void signal_transfer_and_die ( int  signum )

static

Definition at line 231 of file run_kannel_box.c.

References child_box, and remove_pidfile().

Referenced by setup_signals().

{
    /* First send it to the child process */
    if (child_box > 0) {
        kill(child_box, signum);
    }

    /* Prepare to die.  Normally the atexit handler would take care
     * of this when we exit(), but we're going to die from a signal. */
    remove_pidfile();

    /* Then send it to self.  First set the default handler, to
     * avoid catching the signal with this handler again.  This
     * is not a race, because it doesn't matter if we die from
     * the signal we're going to send or from a different one.  */
    signal(signum, SIG_DFL);
    kill(getpid(), signum);
}

write_pidfile()

static void write_pidfile ( void  )

static

Definition at line 128 of file run_kannel_box.c.

References pidfile, and progname.

Referenced by main().

{
    int fd;
    FILE *f;

    if (!pidfile)
        return;

    fd = open(pidfile, O_WRONLY|O_NOCTTY|O_TRUNC|O_CREAT, 0644);
    if (fd < 0) {
        fprintf(stderr, "%s: open: %s: %s\n", progname, pidfile, strerror(errno));
        exit(1);
    }

    f = fdopen(fd, "w");
    if (!f) {
        fprintf(stderr, "%s: fdopen: %s\n", progname, strerror(errno));
        exit(1);
    }

    fprintf(f, "%ld\n", (long)getpid());
    if (fclose(f) < 0) {
        fprintf(stderr, "%s: writing %s: %s\n", progname, pidfile, strerror(errno));
        exit(1);
    }
}

Variable Documentation

box_arglist

char** box_arglist

static

Definition at line 74 of file run_kannel_box.c.

Referenced by build_box_arglist(), and main_loop().

child_box

pid_t child_box

static

Definition at line 76 of file run_kannel_box.c.

Referenced by main_loop(), signal_transfer(), and signal_transfer_and_die().

extra_arguments

char* extra_arguments[]

static

Initial value:

= {
    "-v", "4",   
}

Definition at line 81 of file run_kannel_box.c.

Referenced by build_box_arglist().

min_restart_delay

int min_restart_delay = 60

static

Definition at line 75 of file run_kannel_box.c.

Referenced by main(), and main_loop().

pidfile

char* pidfile

static

Definition at line 77 of file run_kannel_box.c.

Referenced by main(), remove_pidfile(), and write_pidfile().

progname

char* progname

static

Definition at line 73 of file run_kannel_box.c.

Referenced by build_box_arglist(), main(), print_usage(), rebind_standard_streams(), and write_pidfile().

use_extra_args

int use_extra_args = 1

static

Definition at line 78 of file run_kannel_box.c.

Referenced by build_box_arglist(), and main().