root/trunk/TunnelRunner.c

/* $Id: TunnelRunner.c,v 1.1 2004/06/23 08:12:20 bart Exp $ */

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

#define BUFSIZE 4096

int child;

static void sighandler(int s)
{
        if(s != SIGCHLD)
        {
                if(child > 0) {
                        kill(child, s);
                }

                signal(s, SIG_DFL);
                kill(getpid(), s);
        }
}

int main(int argc, char **argv)
{
        int i, r, devnull, status, p[2];
        char *em;
        char buf[BUFSIZE];

        buf[0] = '\0';
        
        if(argc == 3 && strstr(argv[1], "-k") != NULL) {
                setuid(geteuid());
                
                kill(atoi(argv[2]), SIGTERM);
                exit(0);
        }

        if(argc < 2)
        {
                exit(1);
        }

        if(strstr(argv[1], "ssh") == NULL)
        {
                exit(1);
        }

        for(i=1; i < argc; i++) {
                argv[i-1] = argv[i];
                argv[i] = '\0';
        }

        /* Handle some signals. */
        signal(SIGCHLD, sighandler);

        signal(SIGKILL, sighandler);
        signal(SIGTERM, sighandler);
        signal(SIGALRM, sighandler);
        signal(SIGHUP, sighandler);
        signal(SIGINT, sighandler);
        signal(SIGQUIT, sighandler);
        signal(SIGPIPE, sighandler);
        signal(SIGTERM, sighandler);

        if(pipe(p) == -1)
        {
                em = strerror(errno);
                printf("pipe() failed (%s)\n", (em) ? em : "");
                return(-1);
        }
        
        setuid(geteuid());
        
        child = fork();

        /* If the fork failed. */
        if(child == -1)
        {
                em = strerror(errno);
                printf("fork() failed (%s)\n", (em) ? em : "");
                return(-1);
        }

        /* If we're the child. */
        if(child == 0)
        {
                /* Close the read end of the pipe. */
                close(p[0]);

                /* Tie the write end of the pipe to stderr. */
                if(dup2(p[1], STDERR_FILENO) == -1)
                {
                        em = strerror(errno);
                        printf("dup2() failed (%s)\n", (em) ? em : "");
                        exit(1);
                }

                /* We aren't interested in the stuff spewed to stdout. */
                if((devnull = open("/dev/null", O_WRONLY)) == -1)
                {
                        em = strerror(errno);
                        fprintf(stderr, "open failed : %s\n", (em)? em : "");
                        exit(1);
                }

                /* Now direct stdout to our /dev/null filehandle. */
                if(dup2(devnull, STDOUT_FILENO) == -1)
                {
                        em = strerror(errno);
                        fprintf(stderr, "dup2() failed (%s)\n", (em) ? em : "");
                        exit(1);
                }

                /* STDIN should block forever, so we tie it to the writ end of the pipe. */
                while(dup2(p[1], STDIN_FILENO) == -1)
                {
                        em = strerror(errno);
                        fprintf(stderr, "dup2() failed (%s)\n", (em) ? em : "");
                        exit(1);
                }

                /* Execute ssh. */
                if(execv(argv[0], argv) == -1)
                {
                        fprintf(stderr, "execv() failed (%s)\n", strerror(errno));
                        exit(1);
                }

                /* We shouldn't reach this. */
                exit(1);
        }

        /* If we're the father (uh-oh). */
        if(child > 0)
        {
                /* Close the write end of the pipe. */
                close(p[1]);

                for(;;)
                {
                        /* Read until we get EOF. */
                        for(;;)
                        {
                                r = read(p[0], buf, BUFSIZE-1);

                                if((r == -1) && (errno != EINTR))
                                {
                                        em = strerror(errno);
                                        printf("read() failed : %s\n", (em) ? em : "");
                                        exit(1);
                                }

                                else if(r == 0)
                                {
                                        /* We got EOF. Wait for ssh to exit. */
                                        while(waitpid(child, &status, 0) == -1)
                                        {
                                                if(errno == EINTR)
                                                {
                                                        continue;
                                                }

                                                em = strerror(errno);
                                                printf("waitpid() failed (%s)\n", (em) ? em : "");
                                                exit(1);
                                        }

                                        exit(0);
                                }

                                else
                                {
                                        buf[r] = '\0';

                                        if((strstr(buf, "Could not request")) && (strstr(buf, "forwarding")))
                                        {
                                                printf("tunnel failed\n");
                                                kill(child, SIGTERM);
                                        }
                                }
                        }
                }
        }

        return(0);
}